break handler

Can someone please guide me through how to edit break handler and how to make it log off straight away instead of waiting 5 minuted thank you

 

Just replace it with the new break handler. Here is the code for the new break handler which will log out when taking a break:

Code:

   import com.speljohan.rsbot.script.Random;
   import com.speljohan.rsbot.bot.Bot;
   import com.speljohan.rsbot.event.listeners.PaintListener;
   import com.speljohan.rsbot.script.Methods;

   import java.awt.Graphics;
   import java.awt.Color;

   import java.util.ArrayList;
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.Comparator;
   import java.util.Collections;
   import java.util.Enumeration;

   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.util.Properties;

    public class BreakHandler extends Random implements PaintListener {
   
      private final String confFile = "Settings/breaks.txt";
   
      private long startTime = System.currentTimeMillis();
      private ArrayList<Break> breaks = new ArrayList<Break>();
      private Iterator it;
      private Break curBreak;
      private boolean reset;
    
      private boolean setConfigs = true;
      private long curTime = System.currentTimeMillis();
      private long tookBreakAt = 0;
      long breakLength = 0;
    
       public String getName() {
         return "Break Handler";
      }
   
       public String getAuthor() {                //ported to RSBot by ngovil21
         return "regex, sean, pd";
      }
    
       public double getVersion() {
         return 1;
      }
    
       public void onRepaint(Graphics render) {    
         if (tookBreakAt>0 && System.currentTimeMillis() - tookBreakAt < breakLength) {
            render.setColor(Color.yellow);
            long time = breakLength - (System.currentTimeMillis() - tookBreakAt);
            render.drawString("Break Ends in " + cTime(time),420,15);
            return;
         }
         if(tookBreakAt>0) tookBreakAt = 0;
         if (!reset && !checkForActiveScripts()) {
            reset = true;
            log("No Scripts Running. Reset...");
         }
      }
    
       private boolean checkForActiveScripts() {
         try {
            return !Bot.getScriptHandler().getRunningScripts().isEmpty();
         } 
             catch(Exception e) { }
         return false;
      }
    
   
       public void getConfig() {
         Configuration conf = new Configuration(confFile);
      
         for (Enumeration e = conf.propertyNames(); e.hasMoreElements();) {
            String prop = (String) e.nextElement();
            String val = conf.get(prop);
            String breakVal = val.substring(0, val.indexOf(',')).trim();
            String lengthVal = val.substring(val.indexOf(',') + 1).trim();
            long breakAtMin, breakAtMax, lengthMin, lengthMax;
         
            try {
               if (breakVal.indexOf('|') != -1) {
                  breakAtMin = Long.parseLong(
                            breakVal.substring(0, breakVal.indexOf('|')).trim());
                  breakAtMax = Long.parseLong(
                            breakVal.substring(breakVal.indexOf('|') + 1).trim());
               } 
               else {
                  breakAtMax = Long.parseLong(breakVal);
                  breakAtMin = breakAtMax - breakAtMax / 4;
               }
            
               if (lengthVal.indexOf('|') != -1) {
                  lengthMin = Long.parseLong(
                            lengthVal.substring(0, lengthVal.indexOf('|')).trim());
                  lengthMax = Long.parseLong(
                     
                            lengthVal.substring(lengthVal.indexOf('|') + 1).trim());
               } 
               else {
                  lengthMax = Long.parseLong(lengthVal);
                  lengthMin = lengthMax / 2;
               }
            } 
                catch (Exception ex) {
                  log("Exception loading BreakHandler config (" + prop + " = " + val + ")");
                  ex.printStackTrace();
                  continue;
               }
         
            // convert to ms
            breakAtMin *= 60000;
            breakAtMax *= 60000;
            lengthMin *= 60000;
            lengthMax *= 60000;
         
            Break b = new Break(breakAtMin, breakAtMax, lengthMin, lengthMax);
            breaks.add(b);
         }
      
         Collections.sort(breaks,
                new Comparator<Break>() {
                   public int compare(Break b1, Break b2) {
                     return (int) (b1.getBreakAtMin() - b2.getBreakAtMin());
                  }
               });
      
         it = breaks.iterator();
      }
    
    
       public boolean activateCondition() {
         if (setConfigs) {
            getConfig();
            startTime = System.currentTimeMillis();
            setConfigs = false;
         }
         if (breaks.isEmpty())
            return false;
         if (reset) {
            it = breaks.iterator();
            startTime = System.currentTimeMillis();
            reset = false;
         }
         if (curBreak == null)
            curBreak = (Break) it.next();
         curTime = System.currentTimeMillis();
         if (curBreak.shouldBreak(startTime, curTime))
            return true;
      
         return false;
      }
    
       public int loop() {
         if (curBreak == null)
            return -1;
         if (curBreak.getLengthMin() <= 0) {
            log("After " + cTime(curTime - startTime) + ", shutting down.");
            logout();
            reset = true;
            stopAllScripts();
            return -1;
         } 
         else {
            breakLength = curBreak.randLength();
            log("After " + cTime(curTime - startTime)
                    + ", taking break for " + cTime(breakLength));
            if (getMyPlayer().isInCombat()) {
               wait(random(5000,10000));
            }
            if (getMyPlayer().isInCombat()) {
               log("Still In Combat, Waiting To Logout!");
               return random(3000,5000);
            }
            log("Not in Combat, Logging out..");
            logout();
            curBreak = null;
            if (!it.hasNext())
               reset = true;
            tookBreakAt = System.currentTimeMillis();
            return (int)breakLength;
         }
        //return random(1000,2000);
      }
   
       private String cTime(long eTime) {
         long hrs = eTime / 1000 / 3600;
         eTime -= (hrs * 3600 * 1000);
         long mins = eTime / 1000 / 60;
         eTime -= (mins * 60 * 1000);
         long secs = eTime / 1000;
         return String.format("%1$02d:%2$02d:%3$02d", hrs, mins, secs);
      }
    
       public void waitNoException(long t) {
         try {
            Thread.sleep(t);
         } 
             catch (Exception e) {}
      }
   
       protected class Break {
         private final long breakAtMin;
         private final long breakAtMax;
         private final long lengthMin;
         private final long lengthMax;
         private long randBreak=0;
      
          Break(long breakAtMin, long breakAtMax, long lengthMin, long lengthMax) {
            this.breakAtMin = breakAtMin;
            this.breakAtMax = breakAtMax;
            this.lengthMin = lengthMin;
            this.lengthMax = lengthMax;
            this.randBreak = randBreakAt();
         }
      
          private long randLong(long min, long max) {
            return min + (long) (java.lang.Math.random() * (max - min));
         }
      
          public long getBreakAtMin() {
            return breakAtMin;
         }
      
          public long getBreakAtMax() {
            return breakAtMax;
         }
      
          public long getLengthMin() {
            return lengthMin;
         }
      
          public long getLengthMax() {
            return lengthMax;
         }
      
          public long randBreakAt() {
            return randLong(breakAtMin, breakAtMax);
         }
      
          public long randLength() {
            return randLong(lengthMin, lengthMax);
         }
      
          public boolean shouldBreak(long startTime, long curTime) {
            if ((curTime - startTime) > randBreak) {
               randBreak = randBreakAt();
               return true;
            } 
            else
               return false;
         }
      }
    
       public class Configuration {
         private File loadedFrom;
         private Properties props;
         private boolean xml;
      
        /**
         * Reads and parses the specified file; can parse as both
         * XML and standard Properties syntax. If fileName ends with
         * .xml, XML format is assumed.
         *
         * @param fileName The name of the file to parse
         */
          public Configuration(String fileName) {
            loadedFrom = new File(fileName);
            if (fileName.toLowerCase().endsWith(".xml"))
               xml = true;
            props = new Properties();
            if (loadedFrom.exists()) {
               FileInputStream fis = null;
               try {
                  fis = new FileInputStream(loadedFrom);
                  if (xml)
                     props.loadFromXML(fis);
                  else
                     props.load(new FileInputStream(loadedFrom));
               } 
                   catch (IOException ioe) {
                     ioe.printStackTrace();
                  } 
               finally {
                  try {
                     if (fis != null)
                        fis.close();
                  } 
                      catch (IOException e) {
                        e.printStackTrace();
                     }
               }
            }
         }
      
        /**
         * Saves the configuration
         */
          public void save() {
            save(loadedFrom, xml);
         }
      
        /**
         * Saves the configuration to specified filename; if the
         * filename ends with .xml, saves in XML format.
         *
         * @param fileName Filename to save to.
         */
          public void save(String fileName) {
            File f = new File(fileName);
            save(f);
         }
      
        /**
         * Saves the configuration to specified File; if the name of
         * the file ends with .xml, saves in XML format.
         *
         * @param f File object to save to
         */
          public void save(File f) {
            save(f, f.getName().toLowerCase().endsWith(".xml"));
         }
      
        /**
         * Saves the configuration to specified File
         *
         * @param f   File object to save to
         * @param xml Whether to save in XML format
         */
          public void save(File f, boolean xml) {
            FileOutputStream fos = null;
            try {
               if (f.exists())
                  f.delete();
               f.createNewFile();
               fos = new FileOutputStream(f);
               if (xml)
                  props.storeToXML(fos, null);
               else
                  props.store(fos, null);
            } 
                catch (IOException ioe) {
                  ioe.printStackTrace();
               } 
            finally {
               try {
                  if (fos != null)
                     fos.close();
               } 
                   catch (IOException e) {
                     e.printStackTrace();
                  }
            }
         }
      
        /**
         * Gets the value of a key
         *
         * @param key The key to retrieve
         * @return The String value of the given key
         */
          public String get(String key) {
            String rv = props.getProperty(key);
            return rv == null ? "" : rv;
         }
      
        /**
         * Gets the value of a key, with a default value to fall back on
         *
         * @param key          The key to retrieve
         * @param defaultValue The default value to use if no such key was available
         * @return The String value of the given key, or the default value
         */
          public String get(String key, String defaultValue) {
            return props.getProperty(key, defaultValue);
         }
      
          public int getInt(String key) {
            String l = get(key);
            if (!l.equalsIgnoreCase("")) {
               return Integer.parseInt(l);
            } 
            else {
               return -1;
            }
         }
      
        /**
         * Gets an Enumeration of available property names
         *
         * @return Enumeration object containing available properties
         */
          public Enumeration propertyNames() {
            return props.propertyNames();
         }
      
        /**
         * Puts a key/value pair into the configuration
         *
         * @param key   The key to assign a value to
         * @param value The value to assign
         * @return The previous value of the key, or null if it did not have one
         */
          public Object put(String key, String value) {
            return props.setProperty(key, value);
         }
      
        /**
         * Returns the number of available properties
         *
         * @return The number of properties
         */
          public int size() {
            return props.size();
         }
      
      }
   }

 

how do i set what times i want it to take a break
?

 

how do i edit this break handler to when i want the bot to take breaks

 

please guys help

 

the bot is specifically set up to do it completely random so it would be retarded to make it do it at specific times, its there to try and help you seem more human when your botting. as of setting it to automatically log out that is a good idea but it might be better if it only auto logged out like every once in a while, just to make it seem more human