f2pMaples.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.Polygon;
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.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.Arrays;
import java.util.EnumSet;
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.Skills;
import org.rsbot.script.wrappers.RSComponent;
import org.rsbot.script.wrappers.RSInterface;
import org.rsbot.script.wrappers.RSModel;
import org.rsbot.script.wrappers.RSNPC;
import org.rsbot.script.wrappers.RSObject;
import org.rsbot.script.wrappers.RSPath.TraversalOption;
import org.rsbot.script.wrappers.RSTile;
import org.rsbot.util.GlobalConfiguration;

@ScriptManifest(authors = "Magikarp", name = "f2pMaples", version = 1.0, description = "Chops maples in daemonhiem")
public class f2pMaples extends Script implements PaintListener, MouseListener,
        MouseMotionListener {

    // Item IDs
    /**
     * Bronze, iron, steel, black, mith, addy, rune
     */
    final int[] hatchetIDs = { 1351, 1349, 1353, 1361, 1355, 1357, 1359 };
    final static int logID = 1517;
    final int ringID = 15707;

    // Object IDs
    final int treeID = 1307;
    final int treeChoppedID = 7400;
    final int portalInID = 52861;

    // NPC IDs
    final int bankerID = 9710;

    // Animation IDs
    final int idleAnim = -1;
    final int[] choppingAnims = { 879, 877, 875, 873, 871, 869, 867 };
    final int portalInAnim = 13288;
    final int teleLeavingAnim = 13652;
    final int teleArrivingAnim = 13654;

    // Paths
    final RSTile[][] meshToBank = {
            { new RSTile(3453, 3897), new RSTile(3447, 3897) },
            { new RSTile(3448, 3702), new RSTile(3451, 3702) },
            { new RSTile(3451, 3707), new RSTile(3448, 3707) },
            { new RSTile(3448, 3711), new RSTile(3451, 3711) },
            { new RSTile(3451, 3716), new RSTile(3448, 3716) },
            { new RSTile(3448, 3719), new RSTile(3449, 3719),
                    new RSTile(3449, 3718) } };
    final RSTile[][] meshToTrees = {
            { new RSTile(3448, 3720), new RSTile(3452, 3720) },
            { new RSTile(3451, 3717), new RSTile(3448, 3717) },
            { new RSTile(3448, 3711), new RSTile(3451, 3711) },
            { new RSTile(3450, 3707), new RSTile(3449, 3707) },
            { new RSTile(3449, 3703), new RSTile(3450, 3703) },
            { new RSTile(3452, 3701), new RSTile(3449, 3696) },
            { new RSTile(3456, 3692), new RSTile(3455, 3702) },
            { new RSTile(3466, 3704), new RSTile(3463, 3693) },
            { new RSTile(3470, 3694), new RSTile(3472, 3694) },
            { new RSTile(3472, 3690), new RSTile(3470, 3690) },
            { new RSTile(3473, 3684), new RSTile(3474, 3688) },
            { new RSTile(3482, 3688), new RSTile(3482, 3686) },
            { new RSTile(3486, 3686), new RSTile(3486, 3688) },
            { new RSTile(3490, 3695), new RSTile(3492, 3689) },
            { new RSTile(3494, 3693), new RSTile(3494, 3695) },
            { new RSTile(3498, 3695), new RSTile(3498, 3693) },
            { new RSTile(3500, 3690), new RSTile(3503, 3691) },
            { new RSTile(3500, 3682), new RSTile(3496, 3683) },
            { new RSTile(3491, 3677), new RSTile(3494, 3676) },
            { new RSTile(3498, 3668), new RSTile(3490, 3667) },
            { new RSTile(3498, 3660), new RSTile(3499, 3666) },
            { new RSTile(3506, 3667), new RSTile(3505, 3659) },
            { new RSTile(3513, 3665), new RSTile(3513, 3667) } };
    final MeshPath pathToBank = new MeshPath(meshToBank);
    final MeshPath pathToTrees = new MeshPath(meshToTrees);

    // Depricated
    // Areas
    // RSArea bankArea = new RSArea(3445, 3717, 3455, 3723);
    // RSArea maplesArea = new RSArea(3490, 3611, 3508, 3638);
    // RSArea portalArea = new RSArea(3509, 3664, 3513, 3669);

    // States
    State currentState;
    String status;
    int mayAntiBan = 0;

    // Fixing spastic clicking
    boolean clickedPortal = false;
    boolean clickedTree = false;
    int treeCounter = 0;
    int portalCounter = 0;

    // For paint
    final double version = getClass().getAnnotation(ScriptManifest.class)
            .version();
    final String author = PaintFormatter.formatList(getClass().getAnnotation(
            ScriptManifest.class).authors());
    final String name = getClass().getAnnotation(ScriptManifest.class).name();
    public PaintInterface Paint;
    final String baseURL = "http://equinox-scripts.web44.net/scripts/f2pMaples";

    // The main four methods
    public void onRepaint(Graphics render) {
        Graphics2D g = (Graphics2D) render;
        try {
            if (game.isLoggedIn()) {
                Paint.render(g);
                g.setColor(Color.RED);
                g.drawLine(0, (int) (mouse.getLocation().getY()), 800,
                        (int) (mouse.getLocation().getY()));
                g.drawLine((int) (mouse.getLocation().getX()), 0,
                        (int) (mouse.getLocation().getX()), 800);
                pathToTrees.paintMesh(g);
                if (currentState.equals(State.WalkingToBank))
                    pathToBank.paintSmoothPath(g);
                if (currentState.equals(State.WalkingToTrees))
                    pathToTrees.paintSmoothPath(g);
            }

        } catch (Exception e) {
            // log(e.getMessage());
        }
    }

    public boolean onStart() {
        if (!game.isFixed()) {
            log.severe("You must use fixed screen mode to use this script.");
            return false;
        }
        if (game.isLoggedIn()) {
            // Set up script...
            log.info("Welcome to f2pMaples");
            camera.setPitch(random(0, 10));
            mouse.setSpeed(random(7, 9));
            boolean hasHatchet = false;
            boolean hasRing = false;
            game.openTab(Game.TAB_EQUIPMENT);
            log.info("Equipment Check: Checking for a hatchet...");
            if (equipment.containsOneOf(hatchetIDs)) {
                hasHatchet = true;
            }
            log.info("Equipment Check: Checking for a Ring of Kinship...");
            if (equipment.containsOneOf(ringID)) {
                hasRing = true;
            }
            game.openTab(Game.TAB_INVENTORY);
            if (inventory.containsOneOf(hatchetIDs) && !hasHatchet) {
                hasHatchet = true;
            }
            if (!hasHatchet) {
                log.severe("You need a hatchet for this script to run!");
                log.severe("Have one in your inventory or equiped.");
                log.severe("Must be bronze, iron, steel, black, mith, addy, or rune.");
                return false;
            }
            if (!hasRing) {
                log.severe("You need a Ring of Kinship equiped for this script to run!");
                return false;
            }

            // Start Equinox_
            Paint = new PaintInterface(this, log, Skills.WOODCUTTING);
            new DataLoader(this);
            // End Equinox_

        } else {
            log.info("Please log in before starting the script.");
            return false;
        }
        log.info("Anitban: Antiban sleep time -.-");
        sleep(2000, 5000);
        log.info("Antiban: Done");
        log.info("Let's get on with it ");
        return true;
    }

    public void onFinish() {
        log.info("Thanks for using f2pMaples");
        Paint.paintMenu.saveProggie();
        mouse.moveOffScreen();
    }

    public int loop() {
        antiBan();
        try {
            currentState = getState();
            switch (currentState) {
            case Banking:
                mayAntiBan = 0;
                status = "Banking";
                if (pathToTrees.hasPath())
                    pathToTrees.clearPath();
                bank();
                break;
            case WalkingToTrees:
                mayAntiBan = 1;
                status = "Walking to trees";
                if (!pathToTrees.hasPath())
                    pathToTrees.findPath();
                pathToTrees.traverse();
                break;
            case EnteringTrees:
                mayAntiBan = 0;
                status = "Entering tree area";
                RSObject portal = objects.getNearest(portalInID);
                if (!portal.isOnScreen()) {
                    walking.walkTileMM(portal.getArea().getNearestTile(
                            getMyPlayer().getLocation()));
                } else {
                    if (!clickedPortal) {
                        clickObject(portal, "Enter", true);
                        clickedPortal = true;
                        portalCounter = 0;
                    }
                    if (clickedPortal && atPortal() && portalCounter < 5
                            && getMyPlayer().getAnimation() == idleAnim) {
                        portalCounter++;
                    }
                    if (clickedPortal && atPortal() && portalCounter >= 5) {
                        clickedPortal = false;
                        portalCounter = 0;
                    }
                }
                break;
            case Chopping:
                mayAntiBan = 2;
                status = "Chopping trees";
                if (clickedPortal)
                    clickedPortal = false;
                if (pathToBank.hasPath())
                    pathToBank.clearPath();
                cutTree();
                break;
            case WaitingForTrees:
                mayAntiBan = 2;
                status = "Waiting for trees to respawn";
                break;
            case TeleRinging:
                mayAntiBan = 0;
                status = "Using Ring of Kinship";
                sleep(1000, 2000);
                teleRing();
                break;
            case WalkingToBank:
                mayAntiBan = 1;
                status = "Walking to bank";
                if (!pathToBank.hasPath())
                    pathToBank.findPath();
                pathToBank.traverse();
                break;
            case Lost:
                mayAntiBan = 0;
                int angle = camera.getAngle() + random(-45, 45);
                if (angle < 0)
                    angle = random(0, 10);
                if (angle > 359)
                    angle = random(0, 10);
                char whichDir = 37;
                if (random(0, 100) < 50)
                    whichDir = 39;
                keyboard.pressKey(whichDir);
                sleep(random(98, 1302));
                keyboard.releaseKey(whichDir);
                status = "Currently lost";
                sleep(1000, 2000);
            }
        } catch (Exception e) {
            // e.printStackTrace();
        }
        // log(status);
        if (interfaces.canContinue())
            sleep(1000, 2000);
        interfaces.clickContinue();
        return random(100, 125);
    }

    // States 'n stuff
    /**
     * Represents the player's current state
     *
     * @author Magikarp
     */
    private enum State {
        Banking, WalkingToTrees, EnteringTrees, Chopping, WaitingForTrees, TeleRinging, WalkingToBank, Lost
    }

    /**
     * Return the player's current state
     *
     * @author Magikarp
     * @return the player's current state
     */
    private State getState() {
        if (atBank() && inventory.contains(logID)) {
            return State.Banking;
        } else if (!bank.isOpen() && !inventory.contains(logID) && !atPortal()
                && !atTrees()) {
            return State.WalkingToTrees;
        } else if (atPortal()) {
            return State.EnteringTrees;
        } else if (atTrees() && !inventory.isFull()) {
            return State.Chopping;
        } else if (!atTrees() && nearStumps() && !inventory.isFull()) {
            return State.WaitingForTrees;
        } else if (atTrees() && inventory.isFull()) {
            return State.TeleRinging;
        } else if (!atTrees() && !atBank() && inventory.isFull()) {
            return State.WalkingToBank;
        } else {
            return State.Lost;
        }
    }

    // Actually do stuff
    /**
     * Clicks and starts to chop a tree if the player is not already
     *
     * @author Magikarp
     */
    private void cutTree() {
        RSObject tree = objects.getNearest(treeID);
        if (tree != null && calc.tileOnMap(tree.getLocation())) {
            if (!tree.isOnScreen()) {
                walking.walkTileMM(tree.getLocation());
                for (byte b = 0; b < 25; b++) {
                    if (tree.isOnScreen())
                        break;
                    else
                        sleep(50, 75);
                }
            }
            if (getMyPlayer().getAnimation() == idleAnim && !inventory.isFull()
                    && tree.isOnScreen() && !clickedTree
                    && !getMyPlayer().isMoving()) {
                sleep(500, 1000);
                clickObject(tree, "Chop", true);
                clickedTree = true;
                treeCounter = 0;
            } else if (Arrays.asList(choppingAnims).contains(
                    getMyPlayer().getAnimation())
                    && clickedTree) {
                clickedTree = false;
                treeCounter = 0;
            } else if (getMyPlayer().getAnimation() == idleAnim && clickedTree
                    && treeCounter < 5) {
                treeCounter++;
            } else if (getMyPlayer().getAnimation() == idleAnim && clickedTree
                    && treeCounter >= 5) {
                treeCounter = 0;
                clickedTree = false;
            }
        }
    }

    /**
     * Activates the Daemonhiem teleport from the Ring of Kinship
     *
     * @author Magikarp
     */
    public void teleRing() /* throws Exception */{
        if (getMyPlayer().getAnimation() != teleLeavingAnim) {
            game.openTab(Game.TAB_EQUIPMENT, false);
            if (equipment.getItem(Equipment.RING).doAction("Teleport")) {
                sleep(1000, 2000);
                while (getMyPlayer().getAnimation() != idleAnim) {
                    sleep(100, 115);
                }
                game.openTab(Game.TAB_INVENTORY);
            } else {
                log("Didn't use ring, teleport failed. Trying again.");
            }
        }
    }

    // Bank bank bank...
    /**
     * Open bank, deposit, close bank
     *
     * @author Magikarp
     */
    private void bank() {
        if (bank.open()) {
            sleep(250, 500);
            depositBank();
            sleep(250, 500);
            bank.close();
        } else {
            log("Didn't use bank, banking failed.  Trying again.");
        }
    }

    /**
     * Deposit only logs
     *
     * @author Magikarp
     */
    private void depositBank() {
        if (bank.isOpen() && inventory.contains(logID)) {
            sleep(250, 500);
            Paint.logsChopped += inventory.getCount(logID);
            if (inventory.containsOneOf(hatchetIDs)) {
                bank.depositAllExcept(hatchetIDs);
            } else
                bank.depositAll();
        }
    }

    // Where am I?
    /**
     * Checks if the player is at the bank
     *
     * @author Magikarp
     * @return whether the player is at the bank
     */
    private boolean atBank() {
        RSNPC banker = npcs.getNearest(bankerID);
        return banker != null ? banker.isOnScreen() : false;
    }

    /**
     * Checks if the player is at the portal
     *
     * @author Magikarp
     * @return whether the player is at the portal
     */
    private boolean atPortal() {
        RSObject portal = objects.getNearest(portalInID);
        return portal != null ? portal.isOnScreen() : false;
    }

    /**
     * Checks if the player is at the trees
     *
     * @author Magikarp
     * @return whether the player is at the trees
     */
    private boolean atTrees() {
        RSObject tree = objects.getNearest(treeID);
        return tree != null ? calc.tileOnMap(tree.getLocation()) : false;
    }

    /**
     * Checks if the player is at the trees, but checks for stumps instead of
     * trees.
     *
     * @author Magikarp
     * @return whether the player is at the trees w/ stumps
     */
    private boolean nearStumps() {
        RSObject stump = objects.getNearest(treeChoppedID);
        return stump != null ? calc.tileOnMap(stump.getLocation()) : false;
    }

    // StartEquinox_
    /**
     * Use these enums to define the type of path <br />
     * ALL_Center: All points are near the middle of the lines <br />
     * Full: Points can be anywhere on the line<br />
     * WEIGHT_CENTER: Weighted to center, possibility of being on sides, but
     * lower
     *
     * @author Equinox_
     *
     */
    enum MeshPathType {
        ALL_CENTER, FULL, WEIGHT_CENTER
    }

    /**
     * A class that will take a specified mesh, generate a path through it, then
     * round the path off with Bezier curves.
     *
     * @author Equinox_
     *
     */
    public class MeshPath {
        private final Color MESH_FILL = new Color(0.5f, 0.5f, 0.5f, 0.75f);
        private final Color MESH_BORDER = new Color(0.75f, 0.75f, 0.75f, 0.75f);
        private final Color PATH_COLOR = new Color(0f, 1f, 0f, 1f);
        private final Color SMOOTH_PATH_COLOR = new Color(0f, 0f, 1f, 1f);
        private final Color SUBDIVIDED_PATH_COLOR = new Color(1f, 0f, 1f, 1f);

        private List<RSTile[]> mesh = new ArrayList<RSTile[]>();
        private List<RSTile> blockPath = new ArrayList<RSTile>();
        private List<RSTile> smoothPath = new ArrayList<RSTile>();
        private boolean end;
        private List<RSTile> subdividedPath = new ArrayList<RSTile>();

        /**
         * Creates a MeshPath with a blank mesh
         */
        public MeshPath() {

        }

        /**
         * Creates a MeshPath using the provided mesh
         *
         * @param mesh
         *            as RSTile[][]
         */
        public MeshPath(RSTile[][] mesh) {
            setMesh(mesh);
        }

        /**
         * Adds a line to the mesh with the given tiles
         *
         * @param tiles
         *            the RSTiles making up the line
         */
        public void addLine(RSTile... tiles) {
            mesh.add(tiles);
        }

        /**
         * Gets the number of lines in the mesh
         *
         * @return int size
         */
        public int meshSize() {
            return mesh.size();
        }

        /**
         * Adds all the lines of a specified mesh to the current mesh.
         *
         * @param mesh
         *            as RSTile[][]
         */
        public void addMesh(RSTile[][] mesh) {
            for (RSTile[] line : mesh)
                this.mesh.add(line);
        }

        /**
         * Sets the current mesh to the provided mesh
         *
         * @param mesh
         *            as RSTile[][]
         */
        public void setMesh(RSTile[][] mesh) {
            this.mesh.clear();
            addMesh(mesh);
        }

        public List<RSTile> getTilesOnLine(RSTile a, RSTile b) {
            List<RSTile> sublineTiles = new ArrayList<RSTile>();
            int deltaX = b.getX() - a.getX();
            int deltaY = b.getY() - a.getY();
            double dist = calc.distanceBetween(a, b);
            if (dist == 0)
                dist = 1;
            double eX = deltaX / dist, eY = deltaY / dist;
            for (int i = 0; i <= dist; i++)
                sublineTiles.add(new RSTile(a.getX() + (int) (eX * i), a.getY()
                        + (int) (eY * i)));
            return sublineTiles;
        }

        /**
         * Gets all the tiles on the provided line
         *
         * @param line
         *            as RSTile...
         * @return List<RSTile> tiles on line
         */
        public List<RSTile> getTilesOnLines(RSTile... line) {
            List<RSTile> sublineTiles = new ArrayList<RSTile>();
            if (line.length == 1)
                sublineTiles.add(line[0]);
            else
                for (int i = 1; i < line.length; i++) {
                    RSTile a = line[i - 1];
                    RSTile b = line[i];
                    sublineTiles.addAll(getTilesOnLine(a, b));
                }
            return sublineTiles;
        }

        /**
         * Gets a tile on the provided line using the ALL_CENTER method
         *
         * @param line
         *            as RSTile...
         * @return RSTile tile on line
         */
        public RSTile getTileOnLine(RSTile... line) {
            return getTileOnLine(MeshPathType.ALL_CENTER, line);
        }

        /**
         * Gets a tile on the provided line using the provided method
         *
         * @param placement
         *            as MeshPathType
         * @param line
         *            as RSTile...
         * @return RSTile tile on line
         */
        public RSTile getTileOnLine(MeshPathType placement, RSTile... line) {
            List<RSTile> tiles = getTilesOnLines(line);
            int index = 0;
            switch (placement) {
            case ALL_CENTER:
                index = random(tiles.size() / 4, 3 * tiles.size() / 4 + 1);
                // +1 due to exclusive upper bound
                break;
            case FULL:
                index = random(0, tiles.size());
                break;
            case WEIGHT_CENTER:
                index = random(tiles.size() / 4, 3 * tiles.size() / 4 + 1);
                // +1 due to exclusive upper bound

                int rand = random(-10, tiles.size() / 4);
                index += rand > 0 ? rand : 0;
                break;
            }

            if (index < 0)
                index = 0;
            if (index >= tiles.size())
                index = tiles.size() - 1;

            if (tiles.size() > 0)
                return tiles.get(index);
            else
                return null;
        }

        /**
         * Paints the mesh to the provided graphics context in the minimap
         *
         * @param g
         *            as Graphics2D
         */
        public void paintMesh(Graphics2D g) {
            if (mesh.size() > 1) {
                for (int i = 1; i < mesh.size(); i++) {
                    RSTile[] lineA = mesh.get(i - 1).clone();
                    RSTile[] lineB = mesh.get(i).clone();
                    Polygon poly = new Polygon();
                    RSTile a = lineA[0];
                    RSTile b = lineB[0];
                    RSTile c = lineA[lineA.length - 1];
                    RSTile d = lineB[lineB.length - 1];
                    boolean onMap = true;
                    double distA = calc.distanceBetween(c, b)
                            + calc.distanceBetween(a, d);
                    double distB = calc.distanceBetween(a, b)
                            + calc.distanceBetween(c, d);

                    if (distA > distB) {
                        // Reverse lineB.
                        RSTile[] newLineB = new RSTile[lineB.length];
                        int start = lineB.length - 1;
                        for (RSTile t : lineB) {
                            if (start >= 0)
                                newLineB[start] = t;
                            start--;
                        }
                        lineB = newLineB;
                    }

                    if (lineA != null)
                        for (RSTile t : lineA) {
                            Point p = calc.tileToMinimap(t);
                            if (p.x == -1 || p.y == -1) {
                                onMap = false;
                                break;
                            }
                            poly.addPoint(p.x, p.y);
                        }

                    if (lineB != null)
                        for (RSTile t : lineB) {
                            Point p = calc.tileToMinimap(t);
                            if (p.x == -1 || p.y == -1) {
                                onMap = false;
                                break;
                            }
                            poly.addPoint(p.x, p.y);
                        }

                    if (onMap) {
                        g.setColor(MESH_BORDER);
                        g.draw(poly);
                        g.setColor(MESH_FILL);
                        g.fill(poly);
                    }
                }
            }
        }

        public RSTile getTileOnMap(RSTile t) {
            List<RSTile> tiles = getTilesOnLine(t, getMyPlayer().getLocation());
            for (RSTile tt : tiles)
                if (calc.tileOnMap(tt))
                    return tt;
            return null;
        }

        /**
         * Paints the current un-smoothed path to the minimap using the provided
         * graphics object
         *
         * @param g
         *            as Graphics2D
         */
        public void paintPath(Graphics2D g) {
            if (blockPath.size() > 1) {
                g.setColor(PATH_COLOR);
                for (int i = 1; i < blockPath.size(); i++) {
                    Point a = calc.tileToMinimap(blockPath.get(i - 1));
                    Point b = calc.tileToMinimap(blockPath.get(i));
                    if (a.x > 0 && a.y > 0)
                        g.fillOval(a.x - 2, a.y - 2, 5, 5);
                    if (b.x > 0 && b.y > 0)
                        g.fillOval(b.x - 2, b.y - 2, 5, 5);
                    if (a.x > 0 && a.y > 0 && b.x > 0 && b.y > 0)
                        g.drawLine(a.x, a.y, b.x, b.y);
                }
            }
        }

        /**
         * Paints the smoothed version of the current path to the minimap using
         * the provided graphics object
         *
         * @param g
         *            as Graphics2D
         */
        public void paintSmoothPath(Graphics2D g) {
            if (smoothPath.size() > 1) {
                g.setColor(SMOOTH_PATH_COLOR);
                for (int i = 1; i < smoothPath.size(); i++) {
                    Point a = calc.tileToMinimap(smoothPath.get(i - 1));
                    Point b = calc.tileToMinimap(smoothPath.get(i));
                    if (a.x > 0 && a.y > 0)
                        g.fillOval(a.x - 2, a.y - 2, 5, 5);
                    if (b.x > 0 && b.y > 0)
                        g.fillOval(b.x - 2, b.y - 2, 5, 5);
                    if (a.x > 0 && a.y > 0 && b.x > 0 && b.y > 0)
                        g.drawLine(a.x, a.y, b.x, b.y);
                }
            }
        }

        /**
         * Paints the subdivided smoothed version of the current path to the
         * minimap using the provided graphics object
         *
         * @param g
         *            as Graphics2D
         */
        public void paintSubdividedPath(Graphics2D g) {
            if (subdividedPath.size() > 0) {
                g.setColor(SUBDIVIDED_PATH_COLOR);
                for (RSTile t : subdividedPath) {
                    Point tileLoc = calc.tileToMinimap(t);
                    if (tileLoc.x > 0 && tileLoc.y > 0)
                        g.fillOval(tileLoc.x, tileLoc.y, 5, 5);
                }
            }
        }

        /**
         * Paints the mesh, and all versions of the current path to the minimap
         * using the provided graphics object
         *
         * @param g
         *            as Graphics2D
         */
        public void paintAll(Graphics2D g) {
            paintMesh(g);
            paintPath(g);
            paintSmoothPath(g);
            paintSubdividedPath(g);
        }

        /**
         * Finds a path between the start index and the end index using the
         * provided placement type, then sets the current path to the found path
         *
         * @param placement
         *            as MeshPathType
         * @param start
         *            index
         * @param end
         *            index
         */
        public void findPath(MeshPathType placement, int start, int end) {
            blockPath.clear();
            RSTile lineTile = getTileOnLine(mesh.get(start));
            String s = lineTile.toString();
            blockPath.add(lineTile);
            for (int i = start + 1; i <= end; i++) {
                lineTile = getTileOnLine(placement, mesh.get(i));
                blockPath.add(lineTile);
                s += "," + lineTile.toString();
            }
            smoothPath = smoothPath(blockPath);
            subdividedPath = subdividePath(smoothPath);
        }

        /**
         * Finds a path between the beginning and end of the mesh using the
         * provided placement type, then sets the current path to the found path
         *
         * @param placement
         *            as MeshPathType
         */
        public void findPath(MeshPathType placement) {
            findPath(placement, 0, mesh.size() - 1);
        }

        /**
         * Finds a path between the beginning and end of the mesh using the
         * ALL_CENTER placement type, then sets the current path to the found
         * path
         */
        public void findPath() {
            findPath(MeshPathType.ALL_CENTER);
        }

        /**
         * Clears the current path and all refined versions of it.
         */
        public void clearPath() {
            blockPath.clear();
            smoothPath.clear();
            subdividedPath.clear();
        }

        /**
         * Smoothes the provided List of RSTiles using Bezier curves
         *
         * @param path
         *            as List
         * @return List<RSTile> smoothed path
         */
        public List<RSTile> smoothPath(List<RSTile> path) {
            List<RSTile> smoothed = new ArrayList<RSTile>();
            smoothed.addAll(path);
            if (path.size() >= 3) {
                for (int b = 0; b < path.size(); b++) {
                    if (b + 2 < path.size()) {
                        double x2, y2;

                        double t = 0.5;
                        // use Berstein polynomials
                        x2 = (path.get(b + 0).getX() + t
                                * (-path.get(b + 0).getX() * 3 + t
                                        * (3 * path.get(b + 0).getX() - path
                                                .get(b + 0).getX() * t)))
                                + t
                                * (3 * path.get(b + 1).getX() + t
                                        * (-6 * path.get(b + 1).getX() + path
                                                .get(b + 1).getX() * 3 * t))
                                + t
                                * t
                                * (path.get(b + 1).getX() * 3 - path.get(b + 1)
                                        .getX() * 3 * t)
                                + path.get(b + 2).getX() * t * t * t;
                        y2 = (path.get(b + 0).getY() + t
                                * (-path.get(b + 0).getY() * 3 + t
                                        * (3 * path.get(b + 0).getY() - path
                                                .get(b + 0).getY() * t)))
                                + t
                                * (3 * path.get(b + 1).getY() + t
                                        * (-6 * path.get(b + 1).getY() + path
                                                .get(b + 1).getY() * 3 * t))
                                + t
                                * t
                                * (path.get(b + 1).getY() * 3 - path.get(b + 1)
                                        .getY() * 3 * t)
                                + path.get(b + 2).getY() * t * t * t;
                        RSTile loc = new RSTile((int) x2, (int) y2);
                        smoothed.set(b + 1, getTileInMesh(loc));

                    }
                }
            }
            return smoothed;
        }

        /**
         * Gets the nearest tile in the mesh to the provided RSTile
         *
         * @param tile
         *            the RSTile to use
         * @return RSTile tile in mesh
         */
        public RSTile getTileInMesh(RSTile tile) {
            if (inMesh(tile))
                return tile;
            double bestDist = Double.MAX_VALUE;
            RSTile nearest = null;
            if (mesh.size() > 1) {
                for (int i = 1; i < mesh.size(); i++) {
                    RSTile[] lineA = mesh.get(i - 1);
                    RSTile[] lineB = mesh.get(i);
                    if (lineA != null && lineB != null) {
                        RSTile a = lineA[0];
                        RSTile b = lineB[0];
                        RSTile c = lineA[lineA.length - 1];
                        RSTile d = lineB[lineB.length - 1];
                        if (calc.distanceBetween(a, b) > calc.distanceBetween(
                                a, d)) {
                            // Wrong order, switch b and d.
                            RSTile clone = new RSTile(b.getX(), b.getY(),
                                    b.getZ());
                            b = new RSTile(d.getX(), d.getY(), d.getZ());
                            d = clone;
                        }
                        for (RSTile t : getTilesOnLine(a, b)) {
                            double dist = calc.distanceBetween(tile, t);
                            if (dist < bestDist) {
                                bestDist = dist;
                                nearest = t;
                            }
                        }
                        for (RSTile t : getTilesOnLine(c, d)) {
                            double dist = calc.distanceBetween(tile, t);
                            if (dist < bestDist) {
                                bestDist = dist;
                                nearest = t;
                            }
                        }
                    }
                }
            }
            return nearest;
        }

        /**
         * Checks to see if the provided RSTile is inside the mesh
         *
         * @param tile
         *            the RSTile to check
         * @return boolean is in mesh
         */
        public boolean inMesh(RSTile tile) {
            if (mesh.size() > 1) {
                for (int i = 1; i < mesh.size(); i++) {
                    RSTile[] lineA = mesh.get(i - 1);
                    RSTile[] lineB = mesh.get(i);
                    Polygon poly = new Polygon();
                    if (lineA != null)
                        for (RSTile t : lineA)
                            poly.addPoint(t.getX(), t.getY());

                    if (lineB != null)
                        for (RSTile t : lineB)
                            poly.addPoint(t.getX(), t.getY());

                    if (poly.npoints >= 2)
                        if (poly.contains(new Point(tile.getX(), tile.getY())))
                            return true;
                }
            }
            return false;
        }

        /**
         * Takes the provided path and subdivides it using the length provided
         * in the Options class
         *
         * @param smoothPath
         *            path to subdivide as a List<RSTile>
         * @return List<RSTile> subdivided path
         */
        public List<RSTile> subdividePath(List<RSTile> smoothPath) {
            RSTile[] smoothpathArray = new RSTile[smoothPath.size()];
            List<RSTile> path = getTilesOnLines(smoothPath
                    .toArray(smoothpathArray));
            List<RSTile> subdividedPath = new ArrayList<RSTile>();
            RSTile previous = null;
            for (RSTile next : path) {
                if ((previous == null ? true : calc.distanceBetween(previous,
                        next) > Options.walkingDistance.random())
                        || next == path.get(path.size() - 1)) {
                    previous = new RSTile(next.getX(), next.getY());
                    subdividedPath.add(previous);
                }
            }
            return subdividedPath;
        }

        /**
         * Takes a step along this path if appropriate. Specifies only
         * TraversalOption.SPACE_ACTIONS.
         *
         * @return <tt>true</tt> if this path is currently valid for the player;
         *         otherwise <tt>false</tt>.
         * @see #traverse(EnumSet)
         */
        public boolean traverse() {
            return this.traverse(EnumSet.of(TraversalOption.HANDLE_RUN,
                    TraversalOption.SPACE_ACTIONS));
        }

        /**
         * Takes a step along this path if appropriate. If the path cannot be
         * traversed due to the player being too far from its vertices or
         * already at the end vertex, <tt>false</tt> will be returned. In all
         * other cases, <tt>true</tt> will be returned, but an action will not
         * necessarily be performed (based on the given options).
         *
         * @param options
         *            Walking style options.
         * @return <tt>true</tt> if this path is currently valid for the player;
         *         otherwise <tt>false</tt>.
         */
        public boolean traverse(EnumSet<TraversalOption> options) {
            RSTile next = getNext();
            if (next == null)
                return false;
            int nextIdx = getNearestIndexTo(next);

            if (next.equals(getEnd())) {
                if (calc.distanceTo(next) <= 1
                        || (end && players.getMyPlayer().isMoving())
                        || next.equals(walking.getDestination())) {
                    return false;
                }
                end = true;
            } else {
                end = false;
            }
            if (options.contains(TraversalOption.HANDLE_RUN)
                    && !walking.isRunEnabled() && walking.getEnergy() > 50) {
                walking.setRun(true);
                sleep(300);
            }
            if (walking.getDestination() != null
                    && getNearestIndexTo(walking.getDestination()) >= nextIdx)
                return false;
            if (options.contains(TraversalOption.SPACE_ACTIONS)) {
                RSTile dest = walking.getDestination();
                if (dest != null && players.getMyPlayer().isMoving()
                        && calc.distanceBetween(next, dest) < 3) {
                    return true;
                }
            }
            return walking.walkTileMM(next, 0, 0);
        }

        /**
         * Checks whether or not this path can be traversed by the player. This
         * will be the case provided that the player near to one of its
         * vertices, but not already standing on the end vertex.
         *
         * @return <tt>true</tt> if the player can walk along this path;
         *         otherwise <tt>false</tt>.
         */
        public boolean isValid() {
            if (!(subdividedPath.size() > 0 && !players.getMyPlayer()
                    .getLocation().equals(getEnd())))
                return false;
            else
                for (int i = subdividedPath.size() - 1; i >= 0; i--)
                    if (calc.tileOnMap(subdividedPath.get(i)))
                        return true;
            return false;
        }

        /**
         * Gets the start tile of this path.
         *
         * @return The start <code>RSTile</code>.
         */
        public RSTile getStart() {
            if (subdividedPath.size() > 0)
                return subdividedPath.get(0);
            else
                return null;
        }

        /**
         * Gets the next immediately available vertex in this path.
         *
         * @return The next walkable <code>RSTile</code>.
         */
        public RSTile getNext() {
            if (subdividedPath.size() > 0) {
                for (int i = subdividedPath.size() - 1; i >= 0; i--)
                    if (calc.tileOnMap(subdividedPath.get(i)))
                        return subdividedPath.get(i);
                return getTileOnMinimap(getNearest());
            } else
                return null;
        }

        public RSTile getTileOnMinimap(RSTile base) {
            if (calc.tileOnMap(base))
                return base;
            RSTile me = getMyPlayer().getLocation();
            int deltaX = base.getX() - me.getX();
            int deltaY = base.getY() - me.getY();
            double dist = calc.distanceBetween(base, me);
            double eX = deltaX / dist, eY = deltaY / dist;
            return new RSTile(me.getX() + (int) (eX * 14), me.getY()
                    + (int) (eY * 14));
        }

        public RSTile getNearest() {
            int len = Integer.MAX_VALUE;
            RSTile best = null;
            for (RSTile t : subdividedPath)
                if (calc.distanceTo(t) < len) {
                    best = t;
                    len = calc.distanceTo(t);
                }
            return best;
        }

        public RSTile getNearestByPath() {
            int len = Integer.MAX_VALUE;
            RSTile best = null;
            for (RSTile t : subdividedPath) {
                int pLen = calc.pathLengthTo(t, false);
                if (pLen < len && pLen >= 0) {
                    best = t;
                    len = pLen;
                }
            }
            return best;
        }

        public int getNearestIndexTo(RSTile t) {
            int len = Integer.MAX_VALUE;
            int bestIndex = -1;
            if (walking.getDestination() != null)
                for (int i = 0; i < subdividedPath.size(); i++)
                    if (calc.distanceBetween(t, subdividedPath.get(i)) < len) {
                        bestIndex = i;
                        len = calc.distanceTo(t);
                    }
            return bestIndex;
        }

        /**
         * Gets the end tile of this path.
         *
         * @return The end <code>RSTile</code>.
         */
        public RSTile getEnd() {
            if (subdividedPath.size() > 0)
                return subdividedPath.get(subdividedPath.size() - 1);
            else
                return null;
        }

        /**
         * Reverses this mesh.
         *
         * @return
         *
         * @return This path.
         */
        public MeshPath reverse() {
            MeshPath newPath = new MeshPath();
            for (int i = mesh.size() - 1; i >= 0; i--)
                newPath.addLine(mesh.get(i));
            return newPath;
        }

        /**
         * Returns an array containing all of the vertices in this path.
         *
         * @return an array containing all of the vertices in this path.
         */
        public RSTile[] getTilePath() {
            RSTile[] tiles = new RSTile[subdividedPath.size()];
            for (int i = 0; i < tiles.length; i++)
                tiles[i] = new RSTile(subdividedPath.get(i).getX(),
                        subdividedPath.get(i).getY());
            return tiles;
        }

        /**
         * Checks if we have a path
         *
         * @return boolean has a path
         */
        public boolean hasPath() {
            return subdividedPath.size() > 0;
        }
    }

    public static class Options {
        public static Range walkingDistance = new Range(4, 6);
    }

    /**
     * A range class for randomized items
     *
     * @author Equinox_
     *
     */
    public static class Range {
        public int MAX;
        public int MIN;

        public Range(int min, int max) {
            MAX = Math.max(min, max);
            MIN = Math.min(min, max);
        }

        public Range() {
            MAX = 1;
            MIN = -1;
        }

        /**
         * Get a random number in the range
         *
         * @return random int between min and max
         */
        public int random() {
            return (int) (Math.random() * (MAX - MIN)) + MIN;
        }

        public String toString() {
            return MIN + "-" + MAX;
        }
    }

    /**
     * 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 {
        private ModifiedDrawMouse drawMouse = new ModifiedDrawMouse();

        // 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 };

        // Start data
        public long startExp = 0;
        public long startTime = 0;
        public long startLevel = 1;

        // Goal data
        public int goalExp;
        public int goalLevel;

        // Usage data
        public int logsChopped = 0;

        // Price data
        public long logPrice = 1;

        // Result data
        public int runsMade = 0;

        // 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;
        }

        // End Images

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

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

        final f2pMaples chopper;
        final Logger log;
        int SkillID = -1;
        public Menu paintMenu;

        /**
         * Constructs a PaintInterface using the provided parent and logger
         * object
         *
         * @param planker
         *            the parent Natchopper
         * @param log
         *            the Logger object
         */
        public PaintInterface(f2pMaples chopper, Logger log) {
            this(chopper, log, -1);
        }

        public PaintInterface(f2pMaples chopper, Logger log, int SkillID) {
            this.chopper = chopper;
            this.log = log;
            this.SkillID = SkillID;
            startTime = System.currentTimeMillis();
            if (SkillID >= 0 && SkillID < Skills.SKILL_NAMES.length) {
                startExp = skills.getCurrentExp(SkillID);
                startLevel = skills.getCurrentLevel(SkillID);
                setUpGoal();
            }
            init();
        }

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

            MenuButton logging = new MenuButton("logging", paintMenu,
                    "logicon", new GetPopup() {
                        MenuPopUp getPopUp() {
                            long millis = System.currentTimeMillis()
                                    - chopper.Paint.startTime;
                            if (millis <= 0)
                                millis = 1;
                            long logsPerHour = ((logsChopped * 3600000l) / millis);
                            long profit = (logsChopped * logPrice);
                            String[] lines = new String[4];
                            lines[0] = "Logs chopped: "
                                    + PaintFormatter
                                            .getFormattedMoney(logsChopped);
                            lines[1] = "Logs per Hour: "
                                    + PaintFormatter
                                            .getFormattedMoney(logsPerHour);
                            lines[2] = "Profit: "
                                    + PaintFormatter.getFormattedMoney(profit)
                                    + " gp";
                            lines[3] = "Profit per hour: "
                                    + PaintFormatter
                                            .getFormattedMoney((profit * 3600000)
                                                    / millis) + " gp";
                            return new MenuPopUp(lines, "logging");
                        }
                    });
            paintMenu.add(logging);

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

            MenuButton tools = new MenuButton("tools", paintMenu, "toolsicon",
                    new GetPopup() {
                        MenuPopUp getPopUp() {
                            String[] lines = new String[2];
                            lines[0] = "Save proggie";
                            lines[1] = "Reload data";
                            MenuPopUp popUp = new MenuPopUp(lines, "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(chopper);
                                    }
                                }

                                boolean hasAction(String line) {
                                    line = line.toLowerCase().trim();
                                    String[] lines = new String[2];
                                    lines[0] = "Save proggie";
                                    lines[1] = "Reload data";
                                    for (String sub : lines)
                                        if (sub.equalsIgnoreCase(line))
                                            return true;
                                    return false;
                                }
                            });
                            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);
            drawMouse.onRepaint(g);
        }

        /**
         * 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, "tools").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 = chopper.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);
    }

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

        public DataLoader(f2pMaples chopper) {
            super("Data Loader");
            this.chopper = chopper;
            this.start();
        }

        // Item Info
        public void checkGE() {
            long before = System.currentTimeMillis();
            GEItem item = chopper.getGE().lookup(logID);
            if (item != null) {
                chopper.Paint.logPrice = getItemPrice(item);
                chopper.log("Price of " + item.getName() + ": "
                        + getItemPrice(item));
                chopper.log("Loaded log information in "
                        + PaintFormatter.getFormattedTime(System
                                .currentTimeMillis() - before));
            }
        }

        /**
         * 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() {
            checkGE();
            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();
                chopper.Paint.putImage(
                        "homeicon",
                        ImageIO.read(new URL(chopper.baseURL
                                + "/images/houseIcon.png")));
                chopper.log("Loaded home image in "
                        + PaintFormatter.getFormattedTime(System
                                .currentTimeMillis() - before));

                before = System.currentTimeMillis();
                chopper.Paint
                        .putImage(
                                "logicon",
                                getItemImage(logID));
                chopper.log("Loaded runecrafting image in "
                        + PaintFormatter.getFormattedTime(System
                                .currentTimeMillis() - before));

                before = System.currentTimeMillis();
                chopper.Paint.putImage(
                        "toolsicon",
                        ImageIO.read(new URL(chopper.baseURL
                                + "/images/tools.png")));
                chopper.log("Loaded tools icon in "
                        + PaintFormatter.getFormattedTime(System
                                .currentTimeMillis() - before));
            } catch (Exception e) {
                chopper.log("Failed to load images");
            }
        }
    }

    /**
     * Gets the grandExchange singleton for reference by other classes msg
     *
     * @return GrandExchange reference
     */
    public GrandExchange getGE() {
        return grandExchange;
    }

    /**
     * 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 static int getItemPrice(GEItem item) {
        for (Method m : item.getClass().getMethods())
            if (m.getName().equals("getGuidePrice")
                    || m.getName().equals("getMinPrice"))
                try {
                    return (Integer) (m.invoke(item));
                } catch (Exception e) {
                }
        return 0;
    }

    /**
     * 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.mouseLoc = arg0.getPoint();
        Paint.fireMouseEvent(arg0);
    }

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

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

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

    public void mouseReleased(MouseEvent arg0) {
        Paint.mouseLoc = arg0.getPoint();
    }
    // EndEquinox_

    // Start !@!@!
    private boolean clickObject(RSObject object, String action,
            boolean useCentralClicking) {
        Point p;
        int def = mouse.getSpeed();
        for (int i = 0; i < 4; i++) {
            p = useCentralClicking ? getCentralPoint(object.getModel())
                    : getPointOnScreen(object.getModel(), true);
            do {
                p = useCentralClicking ? getCentralPoint(object.getModel())
                        : getPointOnScreen(object.getModel(), false);
                mouse.move(p, 0, 0);
            } while (isPartiallyOnScreen(object.getModel()) && p.x != -1
                    && p.y != -1 && !bank.isOpen()
                    && !mouse.getLocation().equals(p) && !menu.contains(action));
            String[] items = menu.getItems();
            if (items.length > 0
                    && items[0].toLowerCase().startsWith(action.toLowerCase())) {
                mouse.click(true);
                return true;
            } else if (menu.contains(action)) {
                mouse.setSpeed(random(5, 8));
                mouse.click(false);
                sleep(random(100, 200));
                for (int x = 0; x < 4; x++) {
                    if (menu.doAction(action)) {
                        mouse.setSpeed(def);
                        return true;
                    }
                }
            }
            if (!menu.contains(action) && menu.isOpen()) {
                do {
                    mouse.moveRandomly(random(180, 422));
                } while (menu.isOpen());
                sleep(random(75, 220));
                return false;
            }
        }
        return false;
    }

    private boolean isPartiallyOnScreen(RSModel m) {
        return getPointOnScreen(m, true) != null;
    }

    private Point getPointOnScreen(RSModel m, boolean first) {
        if (m == null) {
            return null;
        }
        ArrayList<Point> list = new ArrayList<Point>();
        try {
            Polygon[] tris = m.getTriangles();
            for (int i = 0; i < tris.length; i++) {
                Polygon p = tris[i];
                for (int j = 0; j < p.xpoints.length; j++) {
                    Point pt = new Point(p.xpoints[j], p.ypoints[j]);
                    if (calc.pointOnScreen(pt)) {
                        if (first) {
                            return pt;
                        }
                        list.add(pt);
                    }
                }
            }
        } catch (Exception e) {
        }
        return list.size() > 0 ? list.get(random(0, list.size())) : null;
    }

    private Point getCentralPoint(RSModel m) {
        if (m == null) {
            return null;
        }
        try {
            int x = 0, y = 0, total = 0;
            for (Polygon poly : m.getTriangles()) {
                for (int i = 0; i < poly.npoints; i++) {
                    x += poly.xpoints[i];
                    y += poly.ypoints[i];
                    total++;
                }
            }
            Point central = new Point(x / total, y / total);
            Point curCentral = null;
            double dist = 20000;
            for (Polygon poly : m.getTriangles()) {
                for (int i = 0; i < poly.npoints; i++) {
                    Point p = new Point(poly.xpoints[i], poly.ypoints[i]);
                    if (!calc.pointOnScreen(p)) {
                        continue;
                    }
                    double dist2 = distanceBetween(central, p);
                    if (curCentral == null || dist2 < dist) {
                        curCentral = p;
                        dist = dist2;
                    }
                }
            }
            return curCentral;
        } catch (Exception e) {
        }
        return null;
    }

    private double distanceBetween(Point p1, Point p2) {
        return Math.sqrt(((p1.x - p2.x) * (p1.x - p2.x))
                + ((p1.y - p2.y) * (p1.y - p2.y)));
    }

    // End!@!@!

    // StartUbuntu4life
    private void antiBan() {
        int random = random(1, 5);
        switch (random) {
        case 1:
            if (random(1, 21) != 12)
                return;
            if (mayAntiBan == 2)
                mouse.move(random(10, 750), random(10, 495));
            if (random(1, 7) == 1) {
                if (mayAntiBan == 2)
                    mouse.move(random(10, 750), random(10, 495));
            }
            return;
        case 3:
            if (random(1, 13) != 8)
                return;
            if (mayAntiBan == 2)
                mouse.moveSlightly();
            return;
        case 2:
            if (random(1, 29) != 3)
                return;
            if (random(1, 17) == 1)
                camera.setPitch(true);
            if (mayAntiBan >= 1) {
                int angle = camera.getAngle() + random(-45, 45);
                if (angle < 0)
                    angle = random(0, 10);
                if (angle > 359)
                    angle = random(0, 10);
                char whichDir = 37;
                if (random(0, 100) < 50)
                    whichDir = 39;
                keyboard.pressKey(whichDir);
                sleep(random(98, 1302));
                keyboard.releaseKey(whichDir);
            }
            return;
        default:
            return;
        }
    }
    // EndUbuntu4life
}