EquinoxLunarPlanker.java

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.font.FontRenderContext;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;

import javax.imageio.ImageIO;
import javax.swing.JOptionPane;

import org.rsbot.event.listeners.PaintListener;
import org.rsbot.script.Script;
import org.rsbot.script.ScriptManifest;
import org.rsbot.script.methods.Equipment;
import org.rsbot.script.methods.Game;
import org.rsbot.script.methods.GrandExchange;
import org.rsbot.script.methods.GrandExchange.GEItem;
import org.rsbot.script.methods.Magic;
import org.rsbot.script.methods.Skills;
import org.rsbot.script.wrappers.RSComponent;
import org.rsbot.script.wrappers.RSInterface;
import org.rsbot.script.wrappers.RSItem;
import org.rsbot.util.GlobalConfiguration;

@ScriptManifest(authors = { "Equinox_" }, name = "Equinox_ Lunar Planker", description = "Uses the lunar spell plank-make to create planks.")
public class EquinoxLunarPlanker extends Script implements MouseListener,
        MouseMotionListener, PaintListener {
    PaintInterface Paint;
    ModifiedDrawMouse drawMouse = new ModifiedDrawMouse();

    final String baseURL = "http://equinox-scripts.web44.net/scripts/natcrafter";
    final double VERSION = getClass().getAnnotation(ScriptManifest.class)
            .version();
    final String author = PaintFormatter.formatList(getClass().getAnnotation(
            ScriptManifest.class).authors());
    final String name = PaintFormatter.properCaseAll(getClass().getAnnotation(
            ScriptManifest.class).name());

    // Logs And Planks
    static final int MLog = 6332;
    static final int MPlank = 8782;
    static final int MCost = 1095;
    static final int TLog = 6333;
    static final int TPlank = 8780;
    static final int TCost = 350;
    static final int OLog = 1521;
    static final int OPlank = 8778;
    static final int OCost = 175;
    static final int RLog = 1511;
    static final int RPlank = 960;
    static final int RCost = 70;

    static final int NatRune = 561;
    static final int AstralRune = 9075;
    static final int EarthRune = 557;
    static int PlankID;
    static int LogID;
    static int coinsPerPlank;

    int Coins = 995;
    int logCount = 0;
    int plankCount = 0;
    boolean spellSelected = false;
    Rectangle spell = null;
    Rectangle[] invItems;
    int nextSlot;
    public boolean hasEarthStaff = false;

    int tabTries = 5;
    int invTries = 0;
    int mageTries = 0;

    enum State {
        Cast, Select, Bank, Revert_Magic, Wait
    }

    public RSComponent getSpell(int spell) {
        if (game.getCurrentTab() != Game.TAB_MAGIC) {
            game.openTab(Game.TAB_MAGIC);
            for (int i = 0; i < 100; i++) {
                sleep(20);
                if (game.getCurrentTab() == Game.TAB_MAGIC) {
                    break;
                }
            }
            sleep(random(150, 250));
        }
        if (game.getCurrentTab() == Game.TAB_MAGIC) {
            RSInterface inter = magic.getInterface();
            if (inter != null) {
                RSComponent comp = inter.getComponent(spell);
                return comp;
            }
        }
        return null;
    }

    public boolean onStart() {
        RSItem logI = inventory.getItem(RLog, OLog, TLog, MLog);
        if (logI == null) {
            log.severe("You must start with a Regular, Oak, Teak, or Mahogany log in your inventory!");
            return false;
        }
        switch (logI.getID()) {
        case MLog:
            LogID = MLog;
            coinsPerPlank = MCost;
            PlankID = MPlank;
            break;
        case TLog:
            LogID = TLog;
            coinsPerPlank = TCost;
            PlankID = TPlank;
            break;
        case OLog:
            LogID = OLog;
            coinsPerPlank = OCost;
            PlankID = OPlank;
            break;
        case RLog:
            LogID = RLog;
            coinsPerPlank = RCost;
            PlankID = RPlank;
            break;
        default:
            return false;
        }
        RSItem wep = equipment.getItem(Equipment.WEAPON);
        if (wep != null)
            hasEarthStaff = (wep.getName().toLowerCase().contains("staff") && (wep
                    .getName().toLowerCase().contains("earth") || wep.getName()
                    .toLowerCase().contains("mud")));
        if (!(inventory.containsAll(AstralRune, NatRune))) {
            log.severe("You must start with Astral Runes and Nature Runes in inventory!");
            return false;
        }
        if (!(hasEarthStaff || inventory.contains(EarthRune))) {
            log.severe("You must start with either an Earth-Type staff equipped or Earth Runes in inventory");
            return false;
        }

        Paint = new PaintInterface(this, log, Skills.MAGIC);
        new DataLoader(this);
        logCount = inventory.getCount(LogID);
        plankCount = inventory.getCount(PlankID);
        Paint.startAstrals = inventory.getCount(true, AstralRune);
        Paint.startCoins = inventory.getCount(true, Coins);
        Paint.startEarths = inventory.getCount(true, EarthRune);
        Paint.startNatures = inventory.getCount(true, NatRune);

        RSComponent invIface = inventory.getInterface();
        if (invIface != null)
            if (invIface.isValid()) {
                invItems = new Rectangle[invIface.getComponents().length];
                for (int i = 0; i < invItems.length; i++)
                    invItems[i] = (Rectangle) invIface.getComponent(i)
                            .getArea().clone();
            }

        spell = getSpell(Magic.SPELL_PLANK_MAKE).getArea();
        return true;
    }

    State getState() {
        if (game.getCurrentTab() == Game.TAB_INVENTORY)
            if (inventory.isItemSelected())
                return State.Revert_Magic;
        // "The Abbyssal Services Department apologizes...."
        if (interfaces.canContinue())
            interfaces.clickContinue();
        if (logCount <= 0)
            return State.Bank;
        if (!spellSelected)
            return State.Cast;
        if (spellSelected)
            return State.Select;
        if (logCount <= 0)
            return State.Bank;
        return State.Wait;
    }

    void updateInv() {
        logCount = inventory.getCount(LogID);
        if (inventory.getCount(PlankID) > plankCount)
            Paint.planksMade += inventory.getCount(PlankID) - plankCount;
        plankCount = inventory.getCount(PlankID);
        // if (inventory.getCount(true,Coins) < coinsPerPlank)
        // stopScript(true);
        Paint.usedAstrals = inventory.getCount(true, AstralRune)
                - Paint.startAstrals;
        Paint.usedNatures = inventory.getCount(true, NatRune)
                - Paint.startNatures;
        Paint.usedEarths = inventory.getCount(true, EarthRune)
                - Paint.startEarths;
        Paint.usedCoins = inventory.getCount(true, Coins) - Paint.startCoins;

        Paint.castsLeft = Math.min(inventory.getCount(true, AstralRune) / 2,
                inventory.getCount(true, NatRune));
        if (!hasEarthStaff)
            Paint.castsLeft = Math.min(Paint.castsLeft,
                    inventory.getCount(true, EarthRune) / 15);
        Paint.coinsLeft = inventory.getCount(true, Coins) / coinsPerPlank;
    }

    public int loop() {
        mouse.setSpeed(random(4, 6));
        if (game.getCurrentTab() == Game.TAB_INVENTORY)
            updateInv();

        try {
            switch (getState()) {
            case Cast:
                if (game.getCurrentTab() == Game.TAB_MAGIC && !spellSelected) {
                    if (magic.castSpell(Magic.SPELL_PLANK_MAKE))
                        spellSelected = true;
                    mageTries = 0;
                } else if (mageTries >= tabTries)
                    game.openTab(Game.TAB_MAGIC);
                else
                    mageTries++;
                break;
            case Revert_Magic:
                game.openTab(Game.TAB_MAGIC);
                break;
            case Select:
                if (game.getCurrentTab() == Game.TAB_INVENTORY && spellSelected) {
                    if (getNextLog().doClick(true)) {
                        spellSelected = false;
                        logCount--;
                        plankCount++;
                        invTries = 0;
                        if (spell != null)
                            mouse.move(new Point(spell.x
                                    + random(3, spell.width - 3), spell.y
                                    + random(3, spell.height - 3)));
                    }
                } else if (invTries >= tabTries)
                    game.openTab(Game.TAB_INVENTORY);
                else
                    invTries++;
                break;
            case Bank:
                if (logCount <= 0) {
                    if (!bank.isOpen())
                        bank.open();
                    if (inventory.getCount() != inventory.getCount(AstralRune,
                            NatRune, Coins))
                        bank.depositAllExcept(AstralRune, NatRune, Coins,
                                EarthRune);
                    sleep(500);
                    Paint.logsLeft = bank.getCount(LogID);
                    bank.withdraw(LogID, 0);
                }
                updateInv();
                bank.close();
                if (game.getCurrentTab() != Game.TAB_MAGIC) {
                    game.openTab(Game.TAB_MAGIC);
                    for (int i = 0; i < 100; i++) {
                        sleep(20);
                        if (game.getCurrentTab() == Game.TAB_MAGIC) {
                            break;
                        }
                    }
                    sleep(random(150, 250));
                }
                spellSelected = false;
                nextSlot = 0;
                break;
            }
        } catch (Exception e) {
        }
        return 250;
    }

    public void onRepaint(Graphics render) {
        Graphics2D g = (Graphics2D) render;
        g.setColor(Color.GREEN);
        g.draw(spell);

        g.setColor(Color.RED);
        if (invItems != null)
            if (nextSlot >= 0 && nextSlot < invItems.length)
                g.draw(invItems[nextSlot]);

        drawMouse.onRepaint(render);
        if (Paint != null)
            Paint.render(g);
    }

    public RSItem getNextLog() {
        RSItem[] inv = inventory.getItems();
        // Checks for a plank, then a log, then a plank. Obvious skip.
        for (int i = 1; i < inv.length - 1; i++) {
            RSItem left = inv[i - 1];
            RSItem right = inv[i + 1];
            RSItem thisItem = inv[i];
            if (left != null && right != null && thisItem != null
                    && right.getID() == PlankID && left.getID() == PlankID
                    && thisItem.getID() == LogID) {
                nextSlot = i + 1;
                return thisItem;
            }
        }
        while (nextSlot < inv.length) {
            if (nextSlot >= inv.length)
                nextSlot = 0;
            else if (nextSlot < 0)
                nextSlot = 0;

            if (inv[nextSlot] == null || inv[nextSlot].getID() != LogID) {
                nextSlot++;
                continue;
            } else {
                // all good
                nextSlot++;
                return inv[nextSlot - 1];
            }
        }
        nextSlot = -1;
        return null;
    }

    /**
     * Used to format data into more conventional formats
     *
     * @author Equinox_
     *
     */
    public static class PaintFormatter {
        /**
         * Converts the first letter of every word to uppercase, and the rest
         * lowercase.
         *
         * @param s
         *            The input String
         * @return the properly formatted string
         */
        public static String properCaseAll(String s) {
            String[] words = s.split(" ");
            String result = "";
            for (int i = 0; i < words.length; i++) {
                String f = words[i].substring(0, 1).toUpperCase();
                words[i] = f + words[i].substring(1).toLowerCase();
                result += " " + words[i];
            }
            return result.substring(1);
        }

        /**
         * Capitalizes the first letter of every sentence, with every other
         * letter lowercase.
         *
         * @param s
         *            The input string
         * @return The properly formatted String
         */
        public static String properCaseFirst(String s) {
            String[] sentences = new String[] { s };
            if (s.contains("."))
                sentences = s.split(".");
            String result = "";
            for (int i = 0; i < sentences.length; i++) {
                String f = sentences[i].substring(0, 1).toUpperCase();
                sentences[i] = f + sentences[i].substring(1).toLowerCase();
                result += " " + sentences[i];
            }
            return result.substring(1);
        }

        /**
         * Formats time to DD:HH:MM:SS:MSMS with days and millis optional
         *
         * @param timeMillis
         *            long milliseconds of time
         * @param sep
         *            String seperation character
         * @param millisInc
         *            boolean include milliseconds
         * @return
         */
        public static String getFormattedTime(final long timeMillis,
                String sep, boolean millisInc) {
            long millis = timeMillis;
            final long days = millis / (24 * 1000 * 60 * 60);
            millis -= days * (24 * 1000 * 60 * 60);
            final long hours = millis / (1000 * 60 * 60);
            millis -= hours * 1000 * 60 * 60;
            final long minutes = millis / (1000 * 60);
            millis -= minutes * 1000 * 60;
            final long _seconds = millis / 1000;
            millis -= _seconds * 1000;
            String dayString = String.valueOf(days);
            String hoursString = String.valueOf(hours);
            String minutesString = String.valueOf(minutes);
            String secondsString = String.valueOf(_seconds);
            if (hours < 10) {
                hoursString = 0 + hoursString;
            }
            if (minutes < 10) {
                minutesString = 0 + minutesString;
            }
            if (_seconds < 10) {
                secondsString = 0 + secondsString;
            }
            String s = "";
            if (days > 0)
                s = dayString + sep;
            s += hoursString + sep + minutesString + sep + secondsString;
            if (millisInc)
                s += sep + String.valueOf(millis);
            return s;
        }

        /**
         * Converts the milliseconds to DD:HH:MM:SS with the days optional.
         *
         * @param timeMillis
         *            the number of milliseconds
         * @return the properly formatted time as a String
         */
        public static String getFormattedTime(final long timeMillis) {
            return getFormattedTime(timeMillis, ":", false);
        }

        /**
         * Formats a specified amount into thousands, millions or billions, then
         * adds the proper suffix
         *
         * @param money
         *            the amount of money
         * @return the formatted string
         */
        public static String getFormattedMoney(long money) {
            /*
             * String suffix = ""; int t = 1; if (money >= 10000) { t *= 1000;
             * suffix = "K"; } if (money / t > 10000) { t *= 1000; suffix = "M";
             * } if (money / t > 10000) { t *= 1000; suffix = "B"; } return
             * String.valueOf((money / t)) + suffix;
             */
            return new DecimalFormat("###,###,###,###,###,###").format(money);
        }

        /**
         * Converts an array of strings into one string, using commas and 'and' <br>
         * <br>
         * Examples: <br>
         * {"option1"} returns "option1"<br>
         * {"option1","option2"} returns "option1 and option2"<br>
         * {"op1","op2","op3"} returns "op1, op2, and op3"<br>
         * <br>
         *
         * @param list
         *            The array of strings making up the list.
         * @return The properly formatted string
         */
        public static String formatList(String[] list) {
            String s = "";
            if (list != null)
                if (list.length == 2) {
                    s = list[0] + " and " + list[1];
                } else if (list.length > 2) {
                    for (int i = 0; i < list.length - 1; i++)
                        s += list[i] + ", ";
                    s += "and " + list[list.length - 1];
                } else if (list.length == 1)
                    s = list[0];
            return s;
        }
    }

    /**
     * A class used to represent the paint interface for this script
     *
     * @author Equinox_
     *
     */
    public class PaintInterface {
        // Constant
        public final int[] SKILL_INTERFACES = { Skills.INTERFACE_ATTACK,
                Skills.INTERFACE_DEFENSE, Skills.INTERFACE_STRENGTH,
                Skills.INTERFACE_CONSTITUTION, Skills.INTERFACE_RANGE,
                Skills.INTERFACE_PRAYER, Skills.INTERFACE_MAGIC,
                Skills.INTERFACE_COOKING, Skills.INTERFACE_WOODCUTTING,
                Skills.INTERFACE_FLETCHING, Skills.INTERFACE_FISHING,
                Skills.INTERFACE_FIREMAKING, Skills.INTERFACE_CRAFTING,
                Skills.INTERFACE_SMITHING, Skills.INTERFACE_MINING,
                Skills.INTERFACE_HERBLORE, Skills.INTERFACE_AGILITY,
                Skills.INTERFACE_THIEVING, Skills.INTERFACE_SLAYER,
                Skills.INTERFACE_FARMING, Skills.INTERFACE_RUNECRAFTING,
                Skills.INTERFACE_HUNTER, Skills.INTERFACE_CONSTRUCTION,
                Skills.INTERFACE_SUMMONING, Skills.INTERFACE_DUNGEONEERING };

        // Paint data
        public long startTime = 0;
        public int startLevel;
        public int startExp;
        public int startCoins;
        public int startAstrals;
        public int startEarths;
        public int startNatures;

        // Used info
        public int usedCoins;
        public int usedAstrals;
        public int usedEarths;
        public int usedNatures;

        // Price info
        public int coinsPrice;
        public int astralPrice;
        public int earthPrice;
        public int naturePrice;
        public int plankPrice;
        public int logPrice;

        // Remaining info
        public int castsLeft;
        public int logsLeft;
        public int coinsLeft;

        // Goal
        public int goalExp;
        public int goalLevel;

        public int planksMade;

        // Images
        public Map<String, Image> icons = new HashMap<String, Image>();

        public void putImage(String name, Image img) {
            icons.put(name.toLowerCase(), img);
        }

        public Image getImage(String name) {
            if (icons.containsKey(name.toLowerCase()))
                return icons.get(name.toLowerCase());
            return null;
        }

        public FontRenderContext frc = new FontRenderContext(
                new AffineTransform(), false, false);

        public PaintStyle style = new PaintStyle();
        public Point mouseLoc = new Point(0, 0);

        final EquinoxLunarPlanker planker;
        final Logger log;
        int SkillID = -1;
        public Menu paintMenu;

        /**
         * Constructs a PaintInterface using the provided parent and logger
         * object and no skill progress bars
         *
         * @param planker
         *            the parent NatCrafter
         * @param log
         *            the Logger object
         */
        public PaintInterface(EquinoxLunarPlanker planker, Logger log) {
            this(planker, log, -1);
        }

        /**
         * Constructs a PaintInterface with the provided EquinoxLunarPlanker
         * instance, Logger instance, and SkillID
         *
         * @param planker
         *            EquinoxLunarPlanker
         * @param log
         *            Logger
         * @param SkillID
         *            int
         */
        public PaintInterface(EquinoxLunarPlanker planker, Logger log,
                int SkillID) {
            this.planker = planker;
            this.log = log;
            this.SkillID = SkillID;
            if (SkillID >= 0 && SkillID < Skills.SKILL_NAMES.length) {
                startExp = skills.getCurrentExp(SkillID);
                startTime = System.currentTimeMillis();
                startLevel = skills.getCurrentLevel(SkillID);
                setUpGoal();
            }
            init();
        }

        /**
         * Initializes paintMenu
         */
        public void init() {
            RSComponent screen = interfaces.get(548).getComponent(3);
            Point bottomRight = new Point(screen.getAbsoluteX()
                    + screen.getWidth(), screen.getAbsoluteY()
                    + screen.getHeight());
            paintMenu = new Menu(this, bottomRight, Anchor.DOWN_RIGHT);
            paintMenu.setFlowType(FlowType.HORIZONTAL);
            paintMenu.addMouseListener(new MouseListen() {
                void MouseAction(MouseEvent e) {
                    if (e.getID() == MouseEvent.MOUSE_CLICKED)
                        paintMenu.toggleShowAll();
                }
            });
            if (SkillID >= 0 && SkillID < Skills.SKILL_NAMES.length) {
                MenuProgressBar progressBar = new MenuProgressBar("nextlvl",
                        paintMenu, new GetPercent() {
                            int getPercent() {
                                return skills.getPercentToNextLevel(SkillID);
                            }
                        }, "Next Level", new GetPopup() {
                            MenuPopUp getPopUp() {
                                long millis = Math.abs(System
                                        .currentTimeMillis() - startTime);
                                if (millis <= 0)
                                    millis = 1;
                                long expGained = skills.getCurrentExp(SkillID)
                                        - startExp;
                                long expPerHour = (expGained * 3600000l)
                                        / millis;
                                String TTL = "";
                                int TTLunf = (int) ((expPerHour > 0) ? (((float) skills
                                        .getExpToNextLevel(SkillID))
                                        / ((float) expPerHour) * 3600000f) : 0);
                                if (TTLunf != 0)
                                    TTL = PaintFormatter
                                            .getFormattedTime(TTLunf);
                                else
                                    TTL = "No exp gained";
                                String[] lines = new String[4];
                                lines[0] = "Exp gained: "
                                        + PaintFormatter
                                                .getFormattedMoney(expGained);
                                lines[1] = "Exp per Hour: "
                                        + PaintFormatter
                                                .getFormattedMoney(expPerHour);
                                lines[2] = "Exp 'till level: "
                                        + PaintFormatter.getFormattedMoney(skills
                                                .getExpToNextLevel(SkillID));
                                lines[3] = "Time 'till level: " + TTL;
                                return new MenuPopUp(lines, "nextlevel");
                            }

                        });
                paintMenu.add(progressBar);

                if (goalExp > skills.getCurrentExp(SkillID)) {
                    MenuProgressBar goalBar = new MenuProgressBar("goal",
                            paintMenu, new GetPercent() {
                                int getPercent() {
                                    float expTillGoalStart = goalExp - startExp;
                                    double expGained = skills
                                            .getCurrentExp(SkillID) - startExp;
                                    double result = expGained
                                            / expTillGoalStart;
                                    if (result > 1)
                                        result = 1;
                                    if (result < 0)
                                        result = 0;
                                    return (int) (result * 100);
                                }
                            }, "Goal", new GetPopup() {
                                MenuPopUp getPopUp() {
                                    long millis = Math.abs(System
                                            .currentTimeMillis() - startTime);
                                    if (millis <= 0)
                                        millis = 1;
                                    long expGained = skills
                                            .getCurrentExp(SkillID) - startExp;
                                    long expPerHour = (expGained * 3600000l)
                                            / millis;
                                    int expTillGoal = goalExp
                                            - skills.getCurrentExp(SkillID);
                                    String TTG = "";
                                    int TTGunf = (int) ((expPerHour > 0) ? (((float) expTillGoal)
                                            / ((float) expPerHour) * 3600000f)
                                            : 0);
                                    if (TTGunf != 0)
                                        TTG = PaintFormatter
                                                .getFormattedTime(TTGunf);
                                    else
                                        TTG = "No exp gained";
                                    String[] lines = new String[goalLevel > 0 ? 6
                                            : 5];
                                    int off = goalLevel > 0 ? 1 : 0;
                                    if (goalLevel > 0)
                                        lines[0] = "Goal Level: " + goalLevel;
                                    lines[0 + off] = "Goal Exp: "
                                            + PaintFormatter
                                                    .getFormattedMoney(goalExp);
                                    lines[1 + off] = "Exp gained: "
                                            + PaintFormatter
                                                    .getFormattedMoney(expGained);
                                    lines[2 + off] = "Exp per Hour: "
                                            + PaintFormatter
                                                    .getFormattedMoney(expPerHour);
                                    lines[3 + off] = "Exp 'till goal: "
                                            + PaintFormatter
                                                    .getFormattedMoney(expTillGoal);
                                    lines[4 + off] = "Time 'till goal: " + TTG;
                                    return new MenuPopUp(lines, "goalbar");
                                }

                            });
                    paintMenu.add(goalBar);
                }
            }

            // Actual buttons:
            MenuButton planks = new MenuButton("planks", paintMenu,
                    "plankicon", new GetPopup() {
                        MenuPopUp getPopUp() {
                            long millis = Math.abs(System.currentTimeMillis()
                                    - startTime);
                            if (millis <= 0)
                                millis = 1;
                            int planksPerHour = (int) ((planksMade * 3600000l) / millis);
                            int costPerCastR = 2 * astralPrice + naturePrice
                                    + (hasEarthStaff ? 0 : 15 * earthPrice);
                            int costPerCastLC = logPrice + coinsPerPlank;
                            int costPerCast = costPerCastLC + costPerCastR;
                            int profit = (plankPrice - costPerCast)
                                    * planksMade;
                            int profitPhour = (int) ((profit * 3600000l) / millis);
                            int totalCastsLeft = Math.min(
                                    Math.min(logsLeft, castsLeft), coinsLeft);
                            String[] lines = new String[totalCastsLeft > 0 ? 9
                                    : 7];
                            lines[0] = "Planks made: " + planksMade;
                            lines[1] = "Planks per hour: " + planksPerHour;
                            lines[2] = "Cost per cast: " + costPerCast;
                            lines[3] = "Price of plank: " + plankPrice;
                            lines[4] = "Profit per cast: "
                                    + (costPerCast - plankPrice);
                            lines[5] = "Profit: "
                                    + PaintFormatter.getFormattedMoney(profit);
                            lines[6] = "Profit per hour: " + profitPhour;
                            if (totalCastsLeft > 0) {
                                String timeTillCastsOut = PaintFormatter
                                        .getFormattedTime((long) (((double) totalCastsLeft) / (((double) planksMade) / ((double) millis))));
                                lines[7] = "Casts remaining: " + totalCastsLeft;
                                lines[8] = "No materials in: "
                                        + timeTillCastsOut;
                            }

                            return new MenuPopUp(lines, "planks");

                        }
                    });
            paintMenu.add(planks);

            MenuButton home = new MenuButton("home", paintMenu, "homeicon",
                    new GetPopup() {
                        MenuPopUp getPopUp() {
                            long millis = Math.abs(System.currentTimeMillis()
                                    - startTime);
                            if (millis <= 0)
                                millis = 1;
                            String[] lines = new String[5];
                            lines[0] = planker.name;
                            lines[1] = "By: " + planker.author;
                            lines[2] = "Version " + planker.VERSION;
                            lines[3] = "Runtime: "
                                    + PaintFormatter.getFormattedTime(millis);
                            lines[4] = PaintFormatter.properCaseAll(planker
                                    .getState().name().replace("_", " "));
                            return new MenuPopUp(lines, "home");
                        }
                    });
            paintMenu.add(home);

            MenuButton tools = new MenuButton("tools", paintMenu, "toolsicon",
                    new GetPopup() {
                        MenuPopUp getPopUp() {
                            MenuPopUp popUp = new MenuPopUp(new String[] {
                                    "Save proggie", "Reload data" }, "tools");
                            popUp.addLineListener(new LineListener() {
                                void fireEvent(MouseEvent e, String line) {
                                    line = line.toLowerCase().trim();
                                    if (e.getID() == MouseEvent.MOUSE_CLICKED) {
                                        if (line.contains("save proggie"))
                                            paintMenu.saveProggie();
                                        else if (line.contains("reload data"))
                                            new DataLoader(planker);
                                    }
                                }

                                boolean hasAction(String line) {
                                    line = line.toLowerCase().trim();
                                    return (line.contains("save proggie"))
                                            || (line.contains("reload data"));
                                }
                            });
                            return popUp;
                        }
                    });
            paintMenu.add(tools);

            paintMenu.compile();
        }

        /**
         * Gets the current Goal for the setSkill, or sets all goal variables to
         * -1 if there is no goal
         */
        public void setUpGoal() {
            try {
                for (byte b = 0; b < 10; b++)
                    if (game.getCurrentTab() != Game.TAB_STATS) {
                        game.openTab(Game.TAB_STATS);
                        sleep(1000);
                    } else
                        break;

                RSInterface stats = interfaces.get(320);
                if (stats != null && stats.isValid()) {
                    RSComponent mage = stats
                            .getComponent(SKILL_INTERFACES[SkillID]);
                    if (mage != null && mage.isValid()
                            && mage.getArea() != null) {
                        mouse.move((int) mage.getArea().getCenterX(),
                                (int) mage.getArea().getCenterY());
                        sleep(500, 750);
                        // Now we see what the popup is doing
                        RSComponent pop = stats.getComponent(202);
                        if (pop != null && pop.isValid()) {
                            RSComponent def = pop.getComponent(5);
                            if (def != null && def.isValid()) {
                                if (def.getText().trim()
                                        .equalsIgnoreCase("Target XP:")) {
                                    RSComponent goalXP = pop.getComponent(6);
                                    if (goalXP != null && goalXP.isValid()) {
                                        goalExp = Integer.valueOf(goalXP
                                                .getText().replace(",", "")
                                                .trim());
                                        goalLevel = -1;
                                    }
                                } else {
                                    // Proceed
                                    RSComponent currExp = pop.getComponent(4);
                                    RSComponent goalRemainder = pop
                                            .getComponent(12);
                                    RSComponent goalLvl = pop.getComponent(10);
                                    if (currExp != null && currExp.isValid()
                                            && goalRemainder != null
                                            && goalRemainder.isValid()
                                            && goalLvl != null
                                            && goalLvl.isValid()) {
                                        goalExp = Integer.valueOf(currExp
                                                .getText().replace(",", "")
                                                .trim())
                                                + Integer.valueOf(goalRemainder
                                                        .getText()
                                                        .replace(",", "")
                                                        .trim());
                                        goalLevel = Integer.valueOf(goalLvl
                                                .getText().replace(",", "")
                                                .trim());
                                    }
                                }
                                log.info("Target level: "
                                        + (goalLevel > 0 ? goalLevel : "None"));
                                log.info("Target exp: "
                                        + (goalExp > 0 ? goalExp : "None"));
                                return;
                            }
                        }
                    }
                }
            } catch (Exception e) {
            }
            goalExp = -1;
            goalLevel = -1;
        }

        /**
         * Renders the current paint to the given graphics context.
         *
         * @param g
         *            as the Graphics2D object to render to
         */
        public void render(Graphics2D g) {
            paintMenu.render(g, mouseLoc);
            int mouseX = mouseLoc.x;
            int mouseY = mouseLoc.y;
            g.setColor(Color.RED);
            g.drawLine(mouseX - 5, mouseY - 5, mouseX + 5, mouseY + 5);
            g.drawLine(mouseX - 5, mouseY + 5, mouseX + 5, mouseY - 5);
        }

        /**
         * Fires a MouseEvent in the paintMenu
         *
         * @param e
         *            MouseEvent
         */
        public void fireMouseEvent(MouseEvent e) {
            if (paintMenu.getBoundsFull().contains(e.getPoint()))
                paintMenu.fireMouseEvent(e);
        }

        /**
         * Represents a Menu on a PaintInterface
         *
         * @author Equinox_
         *
         */
        public class Menu {
            final int padding = 1;
            Point location;
            PaintInterface parent;
            PaintStyle style;
            List<MenuItem> components = new ArrayList<MenuItem>();
            final Anchor anchor;
            boolean showAllPopups;
            MenuPopUp visiblePopup = null;
            List<MouseListen> mouseListeners;
            LineListener defaultLineListener;
            private FlowType flowType = FlowType.HORIZONTAL;
            public Dimension bounds;

            /**
             * Constructs a Menu using the provided PaintInterface, Location,
             * Anchor, and the GameScreen as the bounds
             *
             * @param parent
             *            PaintInterface
             * @param location
             *            Point
             * @param anchor
             *            Anchor
             */
            public Menu(PaintInterface parent, Point location, Anchor anchor) {
                this.parent = parent;
                this.style = parent.style;
                this.location = location;
                this.anchor = anchor;

                // Setup dimension
                Rectangle r = interfaces.get(548).getComponent(3).getArea();
                bounds = new Dimension(r.width, r.height);
            }

            /**
             * Sets the FlowType and recompiles the menu
             *
             * @param flowType
             *            FlowType
             */
            public void setFlowType(FlowType flowType) {
                this.flowType = flowType;
                this.compile();
            }

            /**
             * Gets the FlowType
             *
             * @return FlowType
             */
            public FlowType getFlowType() {
                return flowType;
            }

            /**
             * Toggles the showAllPopups state
             * */
            public void toggleShowAll() {
                showAllPopups = !showAllPopups;
            }

            /**
             * Constructs a menu using the provided parent and location,
             * assuming Anchor.UP_LEFT
             *
             * @param parent
             *            PaintInterface
             * @param location
             *            Point
             */
            public Menu(PaintInterface parent, Point location) {
                this(parent, location, Anchor.UP_LEFT);
            }

            /**
             * Adds the specified menu item
             *
             * @param i
             *            MenuItem
             */
            public void add(MenuItem i) {
                i.setIndex(components.size());
                components.add(i);
                compile();
            }

            /**
             * Compiles this menu
             */
            public void compile() {
                for (int i = 0; i < components.size(); i++)
                    components.get(i).compile();
            }

            /**
             * Gets position x based on the menu's anchor
             *
             * @return int
             */
            public int getAbsX() {
                if (anchor.name().contains("LEFT"))
                    return location.x;
                else
                    return location.x - getWidth();
            }

            /**
             * Gets position y based on the menu's anchor
             *
             * @return int
             */
            public int getAbsY() {
                if (anchor.name().contains("UP"))
                    return location.y;
                else
                    return location.y - getHeight();
            }

            /**
             * Gets the maximum width of this menu using the menu's FlowType
             *
             * @return int
             */
            public int getWidth() {
                if (flowType.equals(FlowType.HORIZONTAL)) {
                    int width = padding * components.size();
                    for (MenuItem m : components)
                        if (m.bounds != null)
                            width += m.bounds.width;
                    return width + padding;
                } else {
                    int max = Integer.MIN_VALUE;
                    for (MenuItem m : components)
                        if (m.bounds != null)
                            if (max < m.bounds.width)
                                max = (int) m.bounds.width;
                    return max + (2 * padding);
                }
            }

            /**
             * Gets the maximum height of this menu based of FlowType
             *
             * @return int
             */
            public int getHeight() {
                if (flowType.equals(FlowType.HORIZONTAL)) {
                    int max = Integer.MIN_VALUE;
                    for (MenuItem m : components)
                        if (m.bounds != null)
                            if (max < m.bounds.height)
                                max = (int) m.bounds.height;
                    return max + (2 * padding);
                } else {
                    int height = padding * components.size();
                    for (MenuItem m : components)
                        if (m.bounds != null)
                            height += m.bounds.height;
                    return height + padding;
                }
            }

            /**
             * Gets the current bounds of this menu, with rounded corners if
             * specified
             *
             * @param rounded
             *            boolean
             * @return RoundRectangle2D.Float
             */
            public RoundRectangle2D.Float getArea(boolean rounded) {
                float round = rounded ? style.roundCorner : 0;
                return new RoundRectangle2D.Float(getAbsX(), getAbsY(),
                        getWidth(), getHeight(), round, round);
            }

            public Rectangle getBoundsFull() {
                RoundRectangle2D r1 = getArea(false);
                RoundRectangle2D r2 = visiblePopup != null ? visiblePopup.bkg
                        : getArea(false);
                int x = (int) Math.min(r1.getX(), r2.getX());
                int y = (int) Math.min(r1.getY(), r2.getY());
                int width = (int) Math.max(r1.getX() + r1.getWidth(), r2.getX()
                        + r2.getWidth())
                        - x;
                int height = (int) Math.max(r1.getX() + r1.getHeight(),
                        r2.getX() + r2.getHeight())
                        - y;
                return new Rectangle(x, y, width, height);
            }

            /**
             * Renders the menu to the specified Graphics object using the
             * provided mouse location for any popups
             *
             * @param g
             *            Graphics2D
             * @param mouseLoc
             *            Point
             */
            public void render(Graphics2D g, Point mouseLoc) {
                g.setColor(style.bgColor);
                g.fill(getArea(true));
                MenuPopUp overPopup = null;
                for (MenuItem m : components) {
                    m.render(g);
                    MenuPopUp p = m.getPopUp();
                    if (p != null) {
                        if (m.bounds.contains(mouseLoc)
                                || (m.getPopUp().name
                                        .equalsIgnoreCase(visiblePopup != null ? visiblePopup.name
                                                : "") && rectangleContainsApprox(
                                        visiblePopup.bkg, mouseLoc)))
                            overPopup = m.getPopUp();
                    }
                }
                if (showAllPopups)
                    getAllPopups(true).render(g);
                else if (overPopup != null) {
                    overPopup.render(g);
                }
                visiblePopup = overPopup;
            }

            /**
             * Check if the specified point is within sqrt(2) of the Rectangle
             *
             * @param r
             *            RoundRectangle2D
             * @param p
             *            Point
             * @return boolean contains
             */
            public boolean rectangleContainsApprox(RoundRectangle2D r, Point p) {
                for (int oX = -1; oX <= 1; oX++)
                    for (int oY = -1; oY <= 1; oY++)
                        if (r.contains(new Point(p.x + oX, p.y + oY)))
                            return true;
                return false;
            }

            /**
             * Gets all popups in frontToBack or backToFront order and excluding
             * specified names
             *
             * @param rightToLeft
             *            boolean
             * @param excludeItems
             *            String...
             * @return MenuPopUp
             */
            public MenuPopUp getAllPopups(boolean backToFront,
                    String... excludeItems) {
                List<String> lines = new ArrayList<String>();
                if (components.size() > 0)
                    if (backToFront)
                        for (int i = components.size() - 1; i >= 0; i--) {
                            boolean ignored = false;
                            for (String subS : excludeItems)
                                if (components.get(i).name
                                        .equalsIgnoreCase(subS))
                                    ignored = true;
                            if (!ignored) {
                                MenuPopUp sub = components.get(i).getPopUp();
                                if (sub != null)
                                    for (String line : sub.lines)
                                        if (!containsLine(lines, line))
                                            lines.add(line);
                            }
                        }
                    else
                        for (int i = 0; i < components.size(); i++) {
                            boolean ignored = false;
                            for (String subS : excludeItems)
                                if (components.get(i).name
                                        .equalsIgnoreCase(subS))
                                    ignored = true;
                            if (!ignored) {
                                MenuPopUp sub = components.get(i).getPopUp();
                                if (sub != null)
                                    for (String line : sub.lines)
                                        if (!containsLine(lines, line))
                                            lines.add(line);
                            }
                        }

                String[] linesArr = new String[lines.size()];
                for (int i = 0; i < lines.size(); i++)
                    linesArr[i] = lines.get(i);
                MenuPopUp p = new MenuPopUp(linesArr, "allpopups");
                p.setParent(components.get(components.size() - 1));
                return p;
            }

            /**
             * Checks if the specified array contains the specified line, just
             * the tag, not the data if possible
             *
             * @param lines
             *            List of Strings
             * @param line
             *            String
             * @return boolean contains
             */
            public boolean containsLine(List<String> lines, String line) {
                for (String s : lines)
                    if (s.contains(":") && line.contains(":")) {
                        if (s.split(":")[0]
                                .equalsIgnoreCase(line.split(":")[0]))
                            return true;
                    } else if (s.equalsIgnoreCase(line))
                        return true;
                return false;
            }

            /**
             * Gets a proggie as a BufferedImage
             *
             * @return BufferedImage proggie
             */
            public BufferedImage getProggie() {
                String[] lines = getAllPopups(true, "tools").lines;
                Color color = style.FONT_COLOR;
                Font font = style.FONT;
                float line_height = font.getLineMetrics(lines[0], Paint.frc)
                        .getHeight();
                int width = 0;
                for (String line : lines)
                    if (font.getStringBounds(line, Paint.frc).getWidth() > width)
                        width = (int) font.getStringBounds(line, Paint.frc)
                                .getWidth();

                int height = (int) (lines.length * line_height);

                width += style.roundCorner + 2;
                height += style.roundCorner + 2;

                RoundRectangle2D.Float bkg = new RoundRectangle2D.Float(0, 0,
                        width, height,
                        style.roundCorner > 0 ? style.roundCorner + 1 : 0,
                        style.roundCorner > 0 ? style.roundCorner + 1 : 0);
                RoundRectangle2D.Float fg = new RoundRectangle2D.Float(
                        (float) bkg.getX() + 1, (float) bkg.getY() + 1,
                        width - 2, height - 2, style.roundCorner,
                        style.roundCorner);
                Rectangle txtBounds = new Rectangle(
                        (int) (fg.getX() + (style.roundCorner / 2)),
                        (int) (fg.getY() + (style.roundCorner / 2)),
                        (int) (width - style.roundCorner - 2), (int) (height
                                - style.roundCorner - 2));
                BufferedImage bImg = new BufferedImage(width, height,
                        BufferedImage.TYPE_INT_ARGB);
                Graphics2D g = (Graphics2D) bImg.getGraphics();
                g.setColor(style.bgColor);
                g.fill(bkg);
                g.setColor(style.fgColor);
                g.fill(fg);
                g.setFont(font);
                g.setColor(color);
                for (int i = 0; i < lines.length; i++)
                    g.drawString(lines[i], txtBounds.x,
                            ((i + 1) * (line_height)) + txtBounds.y);
                return bImg;
            }

            /**
             * Saves a progress report to the Screenshots directory
             */
            public void saveProggie() {
                String name = planker.name
                        + "_"
                        + PaintFormatter.getFormattedTime(
                                System.currentTimeMillis() - Paint.startTime,
                                "-", true);
                final File dir = new File(
                        GlobalConfiguration.Paths.getScreenshotsDirectory());
                if (dir.isDirectory() || dir.mkdirs()) {
                    try {
                        int ext = 0;
                        while (new File(dir, name
                                + (ext > 0 ? ("(" + ext + ")") : "") + ".png")
                                .exists())
                            ext++;

                        ImageIO.write(Paint.paintMenu.getProggie(), "png",
                                new File(dir, name
                                        + (ext > 0 ? ("(" + ext + ")") : "")));
                        log.info("Saved proggie!");
                        log.info(new File(dir, name
                                + (ext > 0 ? ("(" + ext + ")") : "") + ".png")
                                .getAbsolutePath());
                    } catch (IOException e) {
                        log.severe("Failed to save proggie!");
                    }
                }
            }

            /**
             * Adds the specified mouse listener
             *
             * @param listen
             *            MouseListen
             */
            public void addMouseListener(MouseListen listen) {
                if (mouseListeners == null)
                    mouseListeners = new ArrayList<MouseListen>();
                mouseListeners.add(listen);
            }

            /**
             * Sets the default line listener
             *
             * @param listen
             *            LineListener
             */
            public void setDefaultLineListener(LineListener listen) {
                defaultLineListener = listen;
            }

            /**
             * Fires the MouseEvent in all containing children and this
             *
             * @param e
             *            MouseEvent
             */
            public void fireMouseEvent(MouseEvent e) {
                if (getArea(true).contains(e.getPoint()))
                    if (mouseListeners != null)
                        for (MouseListen m : mouseListeners)
                            m.MouseAction(e);
                for (MenuItem m : components)
                    if (m.bounds != null)
                        if (m.bounds.contains(e.getPoint()))
                            m.fireMouseEvent(e);
                if (visiblePopup != null)
                    visiblePopup.fireMouseEvent(e);

            }
        }

        /**
         * Represents a class containing the method for getting the popup
         *
         * @author Equinox_
         *
         */
        public abstract class GetPopup {
            abstract MenuPopUp getPopUp();
        }

        /**
         * Represents a modified MouseListener used in MenuEvents
         *
         * @author Equinox_
         *
         */
        public abstract class MouseListen {
            abstract void MouseAction(MouseEvent e);
        }

        /**
         * An abstract class representing MenuItems
         *
         * @author Equinox_
         *
         */
        public abstract class MenuItem {
            final GetPopup getPopup;
            Menu parent;
            RoundRectangle2D.Float bounds;
            int index;
            final int width;
            final int height;
            List<MouseListen> mouseListeners;
            final String name;

            /**
             * Constructs a MenuItem with the given name, parent, getPopup
             * method, width and height
             *
             * @param name
             *            String
             * @param parent
             *            Menu
             * @param getPopup
             *            GetPopup
             * @param width
             *            int
             * @param height
             *            int
             */
            public MenuItem(String name, Menu parent, GetPopup getPopup,
                    int width, int height) {
                this.name = name;
                this.height = height;
                this.width = width;
                this.getPopup = getPopup;
                this.parent = parent;
                this.bounds = new RoundRectangle2D.Float(0, 0, width, height,
                        parent.style.roundCorner, parent.style.roundCorner);
            }

            /**
             * Constructs a MenuItem with the given name, parent, width and
             * height
             *
             * @param name
             *            String
             * @param parent
             *            Menu
             * @param width
             *            int
             * @param height
             *            int
             */
            public MenuItem(String name, Menu parent, int width, int height) {
                this(name, parent, null, width, height);
            }

            /**
             * sets this item's index
             *
             * @param idx
             *            int
             */
            public void setIndex(int idx) {
                this.index = idx;
            }

            /**
             * renders this item to the given Graphics2D
             *
             * @param g
             *            Graphics2D
             */
            abstract void render(Graphics2D g);

            /**
             * Compiles this item
             */
            public void compile() {
                this.bounds = new RoundRectangle2D.Float(0, 0, width, height,
                        parent.style.roundCorner, parent.style.roundCorner);
                bounds.x = getX();
                bounds.y = getY();
            }

            /**
             * Gets the offset from upper left of parent depending on parent's
             * FlowType
             *
             * @return int offsetY
             */
            public int getOffX() {
                if (parent.getFlowType().equals(FlowType.HORIZONTAL)) {
                    int x = 1;
                    for (int i = 0; i < index; i++)
                        x += 1 + parent.components.get(i).bounds.width;

                    return x;
                }
                if (parent.getWidth() > bounds.width)
                    return (int) (parent.getWidth() / 2 - bounds.width / 2);
                return 1;
            }

            /**
             * Gets the offset from upper left of parent depending on parent's
             * FlowType
             *
             * @return int offsetX
             */
            public int getOffY() {
                if (parent.getFlowType().equals(FlowType.VERTICAL)) {
                    int y = 1;
                    for (int i = 0; i < index; i++)
                        y += 1 + parent.components.get(i).bounds.height;

                    return y;
                }
                return 1;
            }

            /**
             * Gets the absolute x
             *
             * @return int absolute x
             */
            public int getX() {
                int x = getOffX() + parent.getAbsX();
                return x;
            }

            /**
             * Gets the absolute y
             *
             * @return int absolute y
             */
            public int getY() {
                int y = getOffY() + parent.getAbsY();
                return y;
            }

            /**
             * Gets this item's popup
             *
             * @return MenuPopUp
             */
            public MenuPopUp getPopUp() {
                if (getPopup != null) {
                    MenuPopUp m = getPopup.getPopUp();
                    m.setParent(this);
                    if (parent.defaultLineListener != null)
                        m.addLineListener(parent.defaultLineListener);
                    return m;
                }
                return null;
            }

            /**
             * Adds a mouselistener
             *
             * @param listen
             *            MouseListen
             */
            public void addMouseListener(MouseListen listen) {
                if (mouseListeners == null)
                    mouseListeners = new ArrayList<MouseListen>();
                mouseListeners.add(listen);
            }

            /**
             * Sends the mouse event to all of this item's listeners
             *
             * @param e
             *            MouseEvent
             */
            public void fireMouseEvent(MouseEvent e) {
                if (mouseListeners != null && mouseListeners.size() > 0)
                    for (MouseListen m : mouseListeners)
                        m.MouseAction(e);
            }
        }

        /**
         * A class representing a mouse over button on the parent menu
         *
         * @author Equinox_
         *
         */
        public class MenuButton extends MenuItem {
            final static int width = 30;
            final static int height = 30;

            String imageIcon;

            /**
             * Constructs a button using the specified name, parent, imageIcon,
             * and getPopup method.
             *
             * @param name
             *            String
             * @param parent
             *            Menu
             * @param imageIcon
             *            String
             * @param getPopUp
             *            GetPopup
             */
            public MenuButton(String name, Menu parent, String imageIcon,
                    GetPopup getPopUp) {
                super(name, parent, getPopUp, width, height);
                this.imageIcon = imageIcon.toLowerCase();
            }

            /**
             * Constructs a button using the specified name, parent, and
             * imageIcon
             *
             * @param name
             *            String
             * @param parent
             *            Menu
             * @param imageIcon
             *            String
             */
            public MenuButton(String name, Menu parent, String imageIcon) {
                this(name, parent, imageIcon, null);
            }

            /**
             * Constructs a button using the specified name and parent
             *
             * @param name
             *            String
             * @param parent
             *            Menu
             */
            public MenuButton(String name, Menu parent) {
                this(name, parent, "", null);
            }

            /**
             * Renders this MenuButton to the given Graphics2D context
             */
            public void render(Graphics2D g) {
                // Compiling
                if (parent.parent.icons.containsKey(imageIcon))
                    if (parent.parent.icons.get(imageIcon) != null)
                        if (!parent.parent.icons.containsKey("Button-"
                                + imageIcon)) {
                            // Scale the image
                            int width = (int) (bounds.width - (parent.style.roundCorner));
                            int height = (int) (bounds.height - (parent.style.roundCorner));
                            int hints = Image.SCALE_FAST;
                            parent.parent.icons.put(
                                    "Button-" + imageIcon,
                                    parent.parent.icons.get(imageIcon)
                                            .getScaledInstance(width, height,
                                                    hints));
                        }

                g.setColor(parent.style.fgColor);
                g.fill(bounds);
                if (parent.parent.icons.containsKey("Button-" + imageIcon))
                    if (parent.parent.icons.get("Button-" + imageIcon) != null)
                        g.drawImage(
                                parent.parent.icons.get("Button-" + imageIcon),
                                (int) (bounds.x + (parent.style.roundCorner / 2)),
                                (int) (bounds.y + (parent.style.roundCorner / 2)),
                                null);
            }
        }

        /**
         * A class representing a progress bar in a menu
         *
         * @author Equinox_
         *
         */
        public class MenuProgressBar extends MenuItem {
            final static int width = 100;
            final static int height = 30;

            final GetPercent getPercent;
            RoundRectangle2D.Float percent;
            Point textLoc;
            String prefix;

            /**
             * Constructs a MenuProgress bar using the specified name, parent,
             * getPercent method, text prefix, and getPopup method
             *
             * @param name
             *            String
             * @param parent
             *            Menu
             * @param getPercent
             *            GetPercent
             * @param prefix
             *            String
             * @param getPopup
             *            GetPopup
             */
            public MenuProgressBar(String name, Menu parent,
                    GetPercent getPercent, String prefix, GetPopup getPopup) {
                super(name, parent, getPopup, width, height);
                this.getPercent = getPercent;
                this.prefix = prefix;
            }

            /**
             * Renders this progress bar to the given Graphics context
             */
            public void render(Graphics2D g) {
                percent.width = getPercent.getPercent();
                g.setColor(parent.style.progressBarBG);
                g.fill(bounds);
                g.setColor(parent.style.progressBarFG);
                g.fill(percent);
                String perct = String.valueOf(getPercent.getPercent());
                if (perct.length() < 2)
                    perct = "0" + perct;
                g.setFont(style.FONT);
                g.setColor(style.FONT_COLOR);
                g.drawString(prefix + ": " + perct + "%", textLoc.x, textLoc.y);
            }

            /**
             * Compiles this progress bar
             */
            public void compile() {
                super.compile();
                percent = new RoundRectangle2D.Float(bounds.x, bounds.y,
                        getPercent.getPercent(), bounds.height,
                        bounds.arcwidth, bounds.archeight);
                textLoc = new Point();
                textLoc.x = (int) bounds.getCenterX();
                textLoc.y = (int) bounds.getCenterY();
                textLoc.y += parent.style.FONT.getLineMetrics(prefix + ": 00%",
                        parent.parent.frc).getHeight() / 2f;
                textLoc.x -= parent.style.FONT.getStringBounds(
                        prefix + ": 00%", parent.parent.frc).getWidth() / 2f;
            }
        }

        /**
         * Class representing the method for getting the current percentile for
         * a progress bar
         *
         * @author Equinox_
         *
         */
        public abstract class GetPercent {
            abstract int getPercent();
        }

        /**
         * Class representing the LineListeners in popups
         *
         * @author Equinox_
         *
         */
        public abstract class LineListener {
            abstract void fireEvent(MouseEvent e, String line);

            abstract boolean hasAction(String line);
        }

        /**
         * A class representing the popups in the paint interface
         *
         * @author Equinox_
         *
         */
        public class MenuPopUp {
            private Font font;
            private Color color;
            private PaintStyle style;
            private RoundRectangle2D bkg;
            public RoundRectangle2D fg;
            public Rectangle txtBounds;
            public MenuItem parent;
            public final String name;
            public String[] lines;
            int width;
            int height;
            List<LineListener> lineListeners;

            /**
             * Creates a popup using the provided array of strings making up the
             * lines and name
             *
             * @param lines
             *            as String[]
             * @param name
             *            as String
             */
            public MenuPopUp(String[] lines, String name) {
                this.name = name;
                this.lines = lines;
            }

            /**
             * Set this popup's parent and compiles locations
             *
             * @param parent
             *            MenuItem
             */
            public void setParent(MenuItem parent) {
                this.parent = parent;
                this.style = parent.parent.style;
                // Calc dimensions
                color = name.equals("tools") ? style.TOOLS_FONT_COLOR
                        : style.FONT_COLOR;
                font = name.equals("tools") ? style.TOOLS_FONT : style.FONT;
                float line_height = font.getLineMetrics(lines[0], Paint.frc)
                        .getHeight();
                width = 0;
                for (String line : lines)
                    if (font.getStringBounds(line, Paint.frc).getWidth() > width)
                        width = (int) font.getStringBounds(line, Paint.frc)
                                .getWidth();

                height = (int) (lines.length * line_height);

                width += style.roundCorner + 2;
                height += style.roundCorner + 2;

                int halfPadding = (parent.parent.padding / 2);
                if (halfPadding < 1 && halfPadding != 0)
                    halfPadding = 1;
                int x = 0;
                int y = 0;
                if (parent.parent.getFlowType().equals(FlowType.HORIZONTAL)) {
                    if (parent.bounds.y - height - parent.parent.padding > 0) {
                        // Above
                        x = (int) (parent.bounds.x - width
                                + parent.bounds.width + halfPadding);
                        if (x < 0)
                            x = (int) (parent.bounds.x - halfPadding);
                        y = (int) (parent.parent.getAbsY() - height);
                    } else {
                        // Below
                        x = (int) (parent.bounds.x - halfPadding);
                        if (x + width > parent.parent.bounds.width)
                            x = (int) (parent.bounds.x - halfPadding - width);
                        y = (int) (parent.parent.getAbsY() + parent.parent
                                .getHeight());
                    }
                } else {
                    // Vertical
                    if (parent.bounds.x - width - parent.parent.padding > 0) {
                        // Left
                        x = (int) (parent.parent.getAbsX() - width);
                        if (parent.bounds.y - height + halfPadding
                                + parent.bounds.height > 0)
                            y = (int) (parent.bounds.y - height + halfPadding + parent.bounds.height);
                        else
                            y = (int) (parent.bounds.y - halfPadding);
                    } else {
                        // Right
                        x = (int) (parent.parent.getAbsX() + parent.parent
                                .getWidth());
                        if (parent.bounds.y - height + halfPadding
                                + parent.bounds.height > 0)
                            y = (int) (parent.bounds.y - height + halfPadding + parent.bounds.height);
                        else
                            y = (int) (parent.bounds.y - halfPadding);
                    }
                }
                bkg = new RoundRectangle2D.Float(x, y, width, height,
                        style.roundCorner > 0 ? style.roundCorner + 1 : 0,
                        style.roundCorner > 0 ? style.roundCorner + 1 : 0);
                fg = new RoundRectangle2D.Float((float) bkg.getX() + 1,
                        (float) bkg.getY() + 1, width - 2, height - 2,
                        style.roundCorner, style.roundCorner);
                txtBounds = new Rectangle(
                        (int) (fg.getX() + (style.roundCorner / 2)),
                        (int) (fg.getY() + (style.roundCorner / 2)),
                        (int) (width - style.roundCorner - 2), (int) (height
                                - style.roundCorner - 2));
            }

            /**
             * Paints this popup to using the provided Graphics2D in relation to
             * it's parent PaintInterface
             *
             * @param g
             *            as Graphics2D
             */
            public void render(Graphics2D g) {
                g.setColor(style.bgColor);
                g.fill(bkg);
                g.setColor(style.fgColor);
                g.fill(fg);

                float line_height = (txtBounds.height - 4) / lines.length;

                g.setFont(font);
                g.setColor(color);
                for (int i = 0; i < lines.length; i++) {
                    if (new Rectangle(txtBounds.x,
                            (int) ((i * (line_height)) + txtBounds.y),
                            txtBounds.width, (int) line_height)
                            .contains(parent.parent.parent.mouseLoc)
                            && hasAction(lines[i])) {
                        g.setColor(style.highlightColor);
                        g.fill(new Rectangle(txtBounds.x,
                                (int) ((i * (line_height)) + 2 + txtBounds.y),
                                txtBounds.width, (int) line_height));
                    }
                    g.setColor(color);
                    g.drawString(lines[i], txtBounds.x,
                            ((i + 1) * (line_height)) + txtBounds.y);
                }
            }

            boolean hasAction(String line) {
                if (lineListeners != null)
                    for (LineListener l : lineListeners)
                        if (l.hasAction(line))
                            return true;
                return false;
            }

            /**
             * Adds the specified line listener
             *
             * @param l
             *            LineListener
             */
            public void addLineListener(LineListener l) {
                if (lineListeners == null)
                    lineListeners = new ArrayList<LineListener>();
                this.lineListeners.add(l);
            }

            /**
             * fires the specified mouse event using this popup's line listeners
             *
             * @param e
             *            MouseEvent
             */
            public void fireMouseEvent(MouseEvent e) {
                if (!bkg.contains(e.getPoint()) || lineListeners == null
                        || lineListeners.size() == 0)
                    return;

                int line_height = (txtBounds.height - 4) / lines.length;

                for (int i = 0; i < lines.length; i++) {
                    Rectangle stringRect = new Rectangle(txtBounds.x,
                            (i * (line_height)) + txtBounds.y, txtBounds.width,
                            line_height);
                    if (stringRect.contains(e.getPoint())) {
                        for (LineListener lineListener : lineListeners)
                            lineListener.fireEvent(e, lines[i]);
                        return;
                    }
                }
            }
        }

    }

    /**
     * Used for specifing the way a menu is layed out.
     *
     * @author Equinox_
     *
     */
    private enum FlowType {
        VERTICAL, HORIZONTAL
    }

    /**
     * Used for anchoring the menu bar
     *
     * @author Equinox_
     *
     */
    private enum Anchor {
        UP_LEFT, UP_RIGHT, DOWN_RIGHT, DOWN_LEFT
    }

    /**
     * Used to style the paint
     *
     * @author Equinox_
     *
     */
    public static class PaintStyle {
        public final Color FONT_COLOR = Color.BLACK;
        public final Font FONT = new Font("Arial", 1, 10)
                .deriveFont(Font.PLAIN);

        public final Font TOOLS_FONT = new Font("Arial", 1, 14)
                .deriveFont(Font.PLAIN);
        public final Color TOOLS_FONT_COLOR = Color.BLACK;

        public final float roundCorner = 10f;
        public final Color progressBarFG = new Color(0f, 1f, 0f, 1f);
        public final Color progressBarBG = new Color(.3f, .3f, .3f, 1f);
        public final Color bgColor = new Color(0f, 0f, 0f, 0.75f);
        final Color fgColor = new Color(.3f, .3f, .3f, 1f);
        final Color highlightColor = new Color(1f, 0f, 0f, 0.05f);
    }

    /**
     * Modified Copy of DrawMouse
     */
    public class ModifiedDrawMouse {
        private MouseTrailing mouseTrailing = new MouseTrailing();
        private ArrayList<Mouses> Click = new ArrayList<Mouses>();
        private long clickLifeTime = 1500;

        public void onRepaint(final Graphics render) {
            if (mouse != null) {
                Point Location = mouse.getLocation();
                if (mouse.isPressed())
                    if (Click.size() <= 5)
                        Click.add(new Mouses(System.currentTimeMillis(),
                                Location));
                mouseTrailing.draw((Graphics2D) render, Color.WHITE);
                render.setColor(Color.GREEN);
                render.drawLine(Location.x - 5, Location.y, Location.x + 5,
                        Location.y);
                render.drawLine(Location.x, Location.y - 5, Location.x,
                        Location.y + 5);
                if (Click.size() > 1)
                    for (Mouses click : Click) {
                        if (mouse.isPressed())
                            if (Click.size() <= 10)
                                Click.add(new Mouses(
                                        System.currentTimeMillis(), Location));
                        float i = ((float) (click.getTime() + clickLifeTime - System
                                .currentTimeMillis()) / (float) clickLifeTime) + 0.25f;
                        if (i > 0) {
                            render.setColor(new Color(1, 0, 0, i > 1 ? 1 : i));
                            render.drawLine(click.getLocation().x - 5,
                                    click.getLocation().y,
                                    click.getLocation().x + 5,
                                    click.getLocation().y);
                            render.drawLine(click.getLocation().x,
                                    click.getLocation().y - 5,
                                    click.getLocation().x,
                                    click.getLocation().y + 5);
                        } else if (System.currentTimeMillis() - click.getTime() >= 1000) {
                            Click.remove(click);
                        }
                    }

            }
        }

        /**
         * @author Baheer (Doout).
         */
        public class MouseTrailing {
            private int LifeTime = 1500;
            private ArrayList<Mouses> Info = new ArrayList<Mouses>();

            private void getLocation() {
                Point m = mouse.getLocation();
                if (Add(m)) {
                    Info.add(new Mouses(System.currentTimeMillis(), m));
                }
            }

            public boolean Add(Point p) {
                for (Mouses Trailing : Info)
                    if (Trailing.getLocation().equals(p))
                        return false;
                return true;
            }

            public void draw(Graphics2D g, Color c) {
                getLocation();
                if (Info.size() > 1)
                    for (int t = 1; t < Info.size(); t++) {
                        Mouses Trailing1 = Info.get(t);
                        Mouses Trailing2 = Info.get(t - 1);
                        float i = (float) (Trailing1.getTime() + LifeTime - System
                                .currentTimeMillis()) / (float) LifeTime;
                        if (i > 0) {
                            g.setColor(new Color(c.getRed() / 255f, c
                                    .getGreen() / 255f, c.getBlue() / 255f, (c
                                    .getAlpha() / 255f) * i));
                            g.drawLine(Trailing1.getLocation().x,
                                    Trailing1.getLocation().y,
                                    Trailing2.getLocation().x,
                                    Trailing2.getLocation().y);
                        }
                    }
                if (Info.size() > 1) {
                    if (System.currentTimeMillis() > Info.get(0).getTime()
                            + LifeTime) {
                        Info.remove(0);
                    }
                }
            }

        }

        private class Mouses {
            private long Time;
            private Point Location;

            public Mouses(long time, Point loc) {
                Time = time;
                Location = loc;
            }

            public long getTime() {
                return Time;
            }

            public Point getLocation() {
                return Location;
            }
        }
    }

    public void mouseDragged(MouseEvent arg0) {
        Paint.mouseLoc = arg0.getPoint();
    }

    public void mouseMoved(MouseEvent arg0) {
        Paint.mouseLoc = arg0.getPoint();
    }

    public void mouseClicked(MouseEvent arg0) {
        Paint.fireMouseEvent(arg0);
    }

    public void mouseEntered(MouseEvent arg0) {

    }

    public void mouseExited(MouseEvent arg0) {

    }

    public void mousePressed(MouseEvent arg0) {

    }

    public void mouseReleased(MouseEvent arg0) {
    }

    /**
     * Loads script data as the actual script runs. Useful for images that are
     * non-essential.
     *
     * @author Equinox_
     *
     */
    public static class DataLoader extends Thread {
        EquinoxLunarPlanker planker;

        /**
         * Creates a dataloader using the specified EquinoxLunarPlanker instance
         *
         * @param planker
         */
        public DataLoader(EquinoxLunarPlanker planker) {
            super("Data Loader");
            this.planker = planker;
            this.start();
        }

        /**
         * Gets the icon for a specified image in the runescape online database.
         *
         * @param id
         *            as int
         * @return Image
         * @throws MalformedURLException
         * @throws IOException
         */
        public Image getItemImage(int id) throws MalformedURLException,
                IOException {
            return ImageIO.read(new URL(
                    "http://services.runescape.com/m=itemdb_rs/3290_obj_sprite.gif?id="
                            + id));
        }

        public void run() {
            try {
                if (JOptionPane.NO_OPTION == JOptionPane.showConfirmDialog(
                        null, "Would you like to load some images?",
                        "Equinox_ Data Loader", JOptionPane.YES_NO_OPTION))
                    throw new Exception();

                long before = System.currentTimeMillis();
                planker.Paint.putImage(
                        "homeicon",
                        ImageIO.read(new URL(planker.baseURL
                                + "/images/houseIcon.png")));
                planker.log("Loaded home image in "
                        + PaintFormatter.getFormattedTime(System
                                .currentTimeMillis() - before));
                before = System.currentTimeMillis();
                planker.Paint.putImage("plankicon", getItemImage(PlankID));
                planker.log("Loaded plank icon in "
                        + PaintFormatter.getFormattedTime(System
                                .currentTimeMillis() - before));
                before = System.currentTimeMillis();
                planker.Paint.putImage(
                        "toolsicon",
                        ImageIO.read(new URL(planker.baseURL
                                + "/images/tools.png")));
                planker.log("Loaded tools icon in "
                        + PaintFormatter.getFormattedTime(System
                                .currentTimeMillis() - before));
            } catch (Exception e) {
                planker.log("Failed to load images");
            }
            loadGE();
        }

        /**
         * Loads the GE Item prices
         */
        void loadGE() {
            planker.Paint.astralPrice = planker.getItemPrice(AstralRune);
            planker.Paint.earthPrice = planker.getItemPrice(EarthRune);
            planker.Paint.naturePrice = planker.getItemPrice(NatRune);
            planker.Paint.plankPrice = planker.getItemPrice(PlankID);
            planker.Paint.logPrice = planker.getItemPrice(LogID);
        }
    }

    /**
     * gets the item price based on class. Works with all versions of
     * grandExchange.class
     *
     * @param item
     *            the GEItem to get the price from
     * @return int the price
     *
     * @author Equinox_
     */
    public int getItemPrice(int id) {
        GEItem item = grandExchange.lookup(id);
        if (item != null) {
            int price = 0;
            for (Method m : item.getClass().getMethods())
                if (m.getName().equals("getGuidePrice")
                        || m.getName().equals("getMinPrice"))
                    try {
                        price = (Integer) (m.invoke(item));
                        break;
                    } catch (Exception e) {
                    }
            log.info("Price of " + item.getName() + ": " + price);
            return price;
        }
        return 0;
    }

}