EquinoxLunarPlanker

import java.awt.*;
import java.awt.event.*;
import java.awt.font.FontRenderContext;
import java.awt.geom.AffineTransform;
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.*;
import java.util.List;
import java.util.logging.Logger;

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

import org.rsbot.Configuration;
import org.rsbot.event.listeners.PaintListener;
import org.rsbot.script.Script;
import org.rsbot.script.ScriptManifest;
import org.rsbot.script.methods.*;
import org.rsbot.script.methods.GrandExchange.GEItem;
import org.rsbot.script.wrappers.*;

@ScriptManifest(authors = { "Equinox_" }, version = 1.1, 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;
    }

    @Override
    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;
    }

    @Override
    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;
    }

    @Override
    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() {
        @Override
        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() {
                @Override
                int getPercent() {
                return skills.getPercentToNextLevel(SkillID);
                }
            }, "Next Level", new GetPopup() {
                @Override
                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() {
                @Override
                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() {
                @Override
                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() {
            @Override
            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() {
            @Override
            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() {
            @Override
            MenuPopUp getPopUp() {
                MenuPopUp popUp = new MenuPopUp(new String[] {
                    "Save proggie", "Reload data" }, "tools");
                popUp.addLineListener(new LineListener() {
                @Override
                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);
                    }
                }

                @Override
                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(
            Configuration.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
         */
        @Override
        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
         */
        @Override
        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
         */
        @Override
        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;
        }
    }
    }

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

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

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

    @Override
    public void mouseEntered(MouseEvent arg0) {

    }

    @Override
    public void mouseExited(MouseEvent arg0) {

    }

    @Override
    public void mousePressed(MouseEvent arg0) {

    }

    @Override
    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));
    }

    @Override
    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;
    }

}