Breakhandler problems...

Ok basically while i'm botting i use 2 accounts, both of which are woodcutting using the same script 'TAIOwoodcutter', basically i have breakhandler enabled on both of them; and usually on the account i'm cutting yews on it works fine, but for some reason on the account thats woodcutting in f2p when that account takes a break, it will take the break, log back in, but not click on the gold bar "click here to play", so basically my accounts sat there logged in but not past the welcome screen.. gets annoying.

Any ideas why this is?

I've got the updated breakhandler + ruski's welcomescreen but it still happens..

 

There is something wrong with the script or your version of breakhandler. Download a new breakhandler or post the problem on the thread for TAIOwoodcutter.

 

Well this is the breakhandler i'm using atm... U know a better one?

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();
        }

    }
}