EquinoxZMICrafter.java

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Random;

import javax.swing.JOptionPane;

import org.rsbot.event.events.MessageEvent;
import org.rsbot.event.listeners.MessageListener;
import org.rsbot.event.listeners.PaintListener;
import org.rsbot.script.Script;
import org.rsbot.script.ScriptManifest;
import org.rsbot.script.methods.Equipment;
import org.rsbot.script.methods.Game;
import org.rsbot.script.methods.GrandExchange;
import org.rsbot.script.methods.GrandExchange.GEItem;
import org.rsbot.script.methods.Magic;
import org.rsbot.script.methods.Skills;
import org.rsbot.script.wrappers.RSComponent;
import org.rsbot.script.wrappers.RSInterface;
import org.rsbot.script.wrappers.RSItem;
import org.rsbot.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.script.wrappers.RSTilePath;

@ScriptManifest(authors = "Equinox_", keywords = "Runecrafting", name = "Equinox_ ZMI Crafter", version = 0.7, description = "Beta Version")
/**
 * @author Equinox_
 */
public class EquinoxZMICrafter extends Script implements MessageListener,
        PaintListener {

    // Variables
    final String baseURL = "http://equinox-scripts.web44.net/scripts/natcrafter";
    final double VERSION = getClass().getAnnotation(ScriptManifest.class)
            .version();
    final String author = PaintFormatter.formatList(getClass().getAnnotation(
            ScriptManifest.class).authors());
    final String name = getClass().getAnnotation(ScriptManifest.class).name();
    public final static int COSMIC_RUNE_ID = 564;
    public final static int ASTRAL_RUNE_ID = 9075;
    public static final int AIR_STAFF_ID = 1405;
    public final static int PURE_ESS_ID = 7936;
    public final static int ZMI_ALTAR_ID = 26847;
    public final static int AIR_RUNE_ID = 556;
    public final static int NPC_CONTACT_ANIM = 4413;
    public final static int BANKER_ID = 6362;
    public final static int CRAFT_RUNE_ANIM = 791;
    public final static int FIRE_RUNE_ID = 554;
    public final static int CRACK_IN = 26844;
    public final static int CRACK_OUT = 26845;
    public final static RSTile alterDet = new RSTile(3314, 4813, 0);
    public final static int PAY_BANK_INTERFACE = 619;
    public final static int LAW_RUNE = 563;
    public final static int ASTRAL_RUNE = 9075;
    public final static int EARTH_RUNE = 557;
    public final static String[] PAY_BANKER_ORDER = { "fire", "air", "mind",
            "body", "water", "earth", "cosmic", "chaos", "astral", "law",
            "death", "blood", "nature", "soul" };

    public final static RSTile[][] SAFE_MESH = { { new RSTile(3273, 4856, 0) },
            { new RSTile(3280, 4848, 0) }, { new RSTile(3279, 4839, 0) },
            { new RSTile(3286, 4832, 0) }, { new RSTile(3297, 4834, 0) },
            { new RSTile(3309, 4836, 0) }, { new RSTile(3320, 4833, 0) },
            { new RSTile(3310, 4828, 0) }, { new RSTile(3301, 4828, 0) },
            { new RSTile(3289, 4829, 0) }, { new RSTile(3280, 4822, 0) },
            { new RSTile(3290, 4820, 0) }, { new RSTile(3301, 4820, 0) },
            { new RSTile(3308, 4820, 0) } };

    public final static RSTile[][] DANGER_MESH = {
            { new RSTile(3272, 4851, 0), new RSTile(3269, 4854, 0) },
            { new RSTile(3272, 4844, 0), new RSTile(3268, 4846, 0) },
            { new RSTile(3271, 4837, 0), new RSTile(3268, 4838, 0) },
            { new RSTile(3272, 4828, 0), new RSTile(3267, 4832, 0) },
            { new RSTile(3273, 4821, 0), new RSTile(3268, 4825, 0) },
            { new RSTile(3270, 4814, 0), new RSTile(3268, 4819, 0) },
            { new RSTile(3275, 4808, 0), new RSTile(3276, 4814, 0) },
            { new RSTile(3283, 4806, 0), new RSTile(3279, 4810, 0) },
            { new RSTile(3288, 4812, 0), new RSTile(3287, 4807, 0) },
            { new RSTile(3295, 4813, 0), new RSTile(3293, 4814, 0) },
            { new RSTile(3300, 4807, 0), new RSTile(3298, 4813, 0) },
            { new RSTile(3309, 4812, 0), new RSTile(3305, 4807, 0) } };
    public final RSTile[] OURANIA_PATH = { new RSTile(2469, 3245),
            new RSTile(2459, 3249), new RSTile(2455, 3239),
            new RSTile(2453, 3232) };
    public final static int POUCH_TRIES = 20;
    public final static int[] food = { 333, 329, 379, 373, 7946, 361, 1901,
            1899, 1897, 1895, 1893, 1891, 2142 };
    public static final int LADDER_ID = 26849;

    // Pouch IDs
    public static class Pouch {
        public final static int SMALL = 5509;
        public final static int MEDIUM = 5510;
        public final static int MEDIUM_DEGRADED = 5511;
        public final static int LARGE = 5512;
        public final static int LARGE_DEGRADED = 5513;
        public final static int GIANT = 5514;
        public final static int GIANT_DEGRADED = 5515;
        public final static int[] ALL = { SMALL, MEDIUM, MEDIUM_DEGRADED,
                LARGE, LARGE_DEGRADED, GIANT, GIANT_DEGRADED };
        public final static int[] ALL_REPAIRED = { SMALL, MEDIUM, LARGE, GIANT };
        public final static int[] ALL_DEGRADED = { MEDIUM_DEGRADED,
                LARGE_DEGRADED, GIANT_DEGRADED };
        public final static int[] ALL_DEGRADEABLE = { MEDIUM, MEDIUM_DEGRADED,
                LARGE, LARGE_DEGRADED, GIANT, GIANT_DEGRADED };
    }

    public static String serverMsg = "";
    public HashMap<PouchType, PouchState> pouches = new HashMap<PouchType, PouchState>();
    State currentState = State.LOST;
    public MeshPath alterMeshPath;
    public MeshPath bankMeshPath;
    public NPCContact npcContact = new NPCContact();
    public OptionsClass.Path pathTypeCurrent;
    public OptionsClass Options = new OptionsClass();

    // Options
    public static class OptionsClass {
        public pouchRepairOption pouchRepair = pouchRepairOption.ONE;
        public boolean hasAirStaff = true;
        public boolean hasEarthStaff = true;
        public PouchCheckSystem pouchCheckSystem = PouchCheckSystem.SERVER_MSG;
        public Range walkingDistance = new Range(4, 6);
        public Path pathType = Path.Danger;
        public boolean chargeEnergy = true;
        public boolean tryOuraniaTeleport = true;
        public boolean onLunars = false;

        enum Path {
            Danger, Safe
        }

        /**
         * When to repair pouches
         *
         * @author Equinox_
         *
         */
        public enum pouchRepairOption {
            ONE, TWO, ALL, NEVER
        }

        /**
         * How to determine a pouch's state
         *
         * @author Equinox_
         *
         */
        public enum PouchCheckSystem {
            SERVER_MSG, INVENTORY_STATUS
        }

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

            /**
             * Returns a normally distributed pseudorandom integer about a mean
             * centered between min and max with a provided standard deviation.
             *
             * @param sd
             *            The standard deviation. A higher value will increase
             *            the probability of numbers further from the mean being
             *            returned.
             * @return Random integer min <= n < max from the normal
             *         distribution described by the parameters.
             */
            public int random(int sd) {
                int mean = MIN + (MAX - MIN) / 2;
                int rand;
                do {
                    rand = (int) (new Random().nextGaussian() * sd + mean);
                } while (rand < MIN || rand >= MAX);
                return rand;
            }

            /**
             * Returns a normally distributed pseudorandom integer about a mean
             * centered between min and max with a calculated standard
             * deviation.
             *
             * @return Random integer min <= n < max from the normal
             *         distribution described by the parameters.
             */
            public int randomNormalDistribution() {
                int mean = MIN + (MAX - MIN) / 2;
                int rand;
                int sd = (MAX - MIN) / 3;
                do {
                    rand = (int) (new Random().nextGaussian() * sd + mean);
                } while (rand < MIN || rand >= MAX);
                return rand;
            }

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

    public static int[] mergeArrays(int[] a1, int... a2) {
        int[] newArr = new int[a1.length + a2.length];
        for (int i = 0; i < a1.length; i++)
            newArr[i] = a1[i];
        for (int i = 0; i < a2.length; i++)
            newArr[a1.length + i] = a2[i];
        return newArr;
    }

    /**
     * Possible states in the process of nature runecrafting
     *
     * @author Equinox_
     *
     */
    public enum State {
        NEAR_BANK, NPC_CONTACT, BANK_WITHDRAW, BANK_DEPOSIT, FILL_POUCHES, TRAVERSE_ALTER, CRAFT_RUNES, EMPTY_POUCHES, TRAVERSE_BANK, LOST, EAT_FOOD, CHARGE_ENERGY, OURANIA_TELEPORT, LADDER_DOWN, TRAVERSE_OURANIA
    }

    /**
     * Possible states of pouches, Empty or Full
     *
     * @author Equinox_
     *
     */
    public enum PouchState {
        Empty, Full
    }

    /**
     * Different pouches and their possible IDs
     *
     * @author Equinox_
     *
     */
    public enum PouchType {
        Small(Pouch.SMALL), Medium(Pouch.MEDIUM, Pouch.MEDIUM_DEGRADED), Large(
                Pouch.LARGE, Pouch.LARGE_DEGRADED), Giant(Pouch.GIANT,
                Pouch.GIANT_DEGRADED);
        public int[] ids;

        private PouchType(int... ids) {
            this.ids = ids;
        }
    }

    /**
     * Gets the current state
     *
     * @return State the current state
     * @throws Exception
     *             so we can pipe errors back to the recorder
     */
    public State getState() throws Exception {
        if (objects.getNearest(LADDER_ID) != null
                && objects.getNearest(LADDER_ID).isOnScreen())
            return State.LADDER_DOWN;
        if (objects.getNearest(ZMI_ALTAR_ID) != null
                && objects.getNearest(ZMI_ALTAR_ID).getLocation() != null)
            if (calc.tileOnMap(objects.getNearest(ZMI_ALTAR_ID).getLocation())
                    && (Options.pathType.equals(OptionsClass.Path.Danger) || calc
                            .pathLengthTo(alterDet, true) <= 15)) {
                if ((inventory.isFull() || !pouches
                        .containsValue(PouchState.Full))
                        && inventory.contains(PURE_ESS_ID))
                    return State.CRAFT_RUNES;
                else if (pouches.containsValue(PouchState.Full))
                    return State.EMPTY_POUCHES;
                // Check path type change
                if (!pathTypeCurrent.equals(Options.pathType)) {
                    pathTypeCurrent = Options.pathType;
                    // Set up path:
                    if (Options.pathType.equals(OptionsClass.Path.Danger))
                        alterMeshPath = new MeshPath(DANGER_MESH);
                    else
                        alterMeshPath = new MeshPath(SAFE_MESH);
                    bankMeshPath = alterMeshPath.reverse();
                }
            }

        // Banking
        if (npcs.getNearest(BANKER_ID) != null) {
            if (npcs.getNearest(BANKER_ID).isOnScreen() || bank.isOpen()) {
                // Check path type change
                if (!pathTypeCurrent.equals(Options.pathType)) {
                    pathTypeCurrent = Options.pathType;
                    // Set up path:
                    if (Options.pathType.equals(OptionsClass.Path.Danger))
                        alterMeshPath = new MeshPath(DANGER_MESH);
                    else
                        alterMeshPath = new MeshPath(SAFE_MESH);
                    bankMeshPath = alterMeshPath.reverse();
                }
                if (!bank.isOpen() && walking.getEnergy() < 10
                        && Options.chargeEnergy)
                    return State.CHARGE_ENERGY;
                // Pouch Repair
                if (shouldRepairPouches())
                    return State.NPC_CONTACT;
                if ((combat.getLifePoints() + 200 < skills
                        .getCurrentLevel(Skills.CONSTITUTION) * 10)
                        || combat.getHealth() < 50)
                    return State.EAT_FOOD;
                if (inventory.getCount(Pouch.ALL)
                        + inventory.getCount(PURE_ESS_ID)
                        + inventory.getCount(FIRE_RUNE_ID) != inventory
                        .getCount())
                    return State.BANK_DEPOSIT;

                if (inventory.contains(PURE_ESS_ID)
                        && pouches.containsValue(PouchState.Empty))
                    return State.FILL_POUCHES;

                if (!inventory.isFull())
                    return State.BANK_WITHDRAW;
            } else if (!inventory.contains(PURE_ESS_ID))
                return State.NEAR_BANK;

        }

        if (inventory.contains(PURE_ESS_ID) && !shouldRepairPouches())
            return State.TRAVERSE_ALTER;
        else {
            if (objects.getNearest(LADDER_ID) != null)
                return State.TRAVERSE_OURANIA;
            if (Options.tryOuraniaTeleport
                    && skills.getCurrentLevel(Skills.MAGIC) >= 71
                    && inventory.contains(LAW_RUNE)
                    && inventory.getCount(true, ASTRAL_RUNE) >= 2
                    && (inventory.getCount(true, EARTH_RUNE) >= 6 || Options.hasEarthStaff))
                return State.OURANIA_TELEPORT;
            return State.TRAVERSE_BANK;
        }
        // return State.LOST;
    }

    /**
     * Internal use only. When the client receives a message this method is
     * invoked, saving the message for later use.
     */
    public void messageReceived(MessageEvent msg) {
        if (msg.getID() == MessageEvent.MESSAGE_ACTION
                || msg.getID() == MessageEvent.MESSAGE_SERVER) {
            serverMsg = msg.getMessage().toLowerCase();
        }
    }

    /**
     * Determines if pouches need repairing by using the method defined in the
     * Options class
     *
     * @return boolean should repair pouches
     */
    public boolean shouldRepairPouches() {
        int degradeable = inventory.getCount(Pouch.ALL_DEGRADEABLE);
        int degraded = inventory.getCount(Pouch.ALL_DEGRADED);
        switch (Options.pouchRepair) {
        case ONE:
            return degraded > 0;
        case TWO:
            return degraded > 1 || degradeable < 2;
        case ALL:
            return degradeable == degraded;
        case NEVER:
            return false;
        default:
            return degraded > 1 || degradeable < 2;
        }
    }

    /**
     * Tries to open the bank
     *
     * @return boolean did bank open
     */
    public boolean openBank() {
        if (!alterMeshPath.hasPath())
            alterMeshPath.findPath();
        if (bankMeshPath.hasPath())
            bankMeshPath.clearPath();

        for (byte b = 0; b < 10; b++) {
            if (interfaces.get(PAY_BANK_INTERFACE) != null
                    && interfaces.get(PAY_BANK_INTERFACE).isValid())
                payBankCharge();
            if (npcs.getNearest(BANKER_ID) != null) {
                if (bank.isOpen())
                    return true;
                npcs.getNearest(BANKER_ID).doAction("Bank");
                sleep(100, 250);
            }
            sleep(1000);
        }
        return false;
    }

    public void payBankCharge() {
        RSInterface pay = interfaces.get(PAY_BANK_INTERFACE);
        if (pay != null && pay.isValid())
            for (String rune : PAY_BANKER_ORDER)
                for (RSComponent c : pay.getComponents())
                    if (c != null
                            && c.isValid()
                            && c.getTooltip() != null
                            && c.getTooltip().toLowerCase()
                                    .contains(rune.toLowerCase()))
                        if (inventoryCount(rune) >= 20)
                            if (c.doClick()) {
                                sleep(1500);
                                return;
                            }
        log.severe("Unable to pay banker!");
    }

    public int inventoryCount(String name) {
        for (RSItem i : inventory.getCachedItems())
            if (i != null
                    && i.getName().toLowerCase().contains(name.toLowerCase()))
                return i.getStackSize();
        return 0;
    }

    /**
     * Deposit all non necessary items.
     */
    public void deposit() {
        if (!openBank())
            return;
        int invBefore = inventory.getCount();
        int pouchesBefore = inventory.getCount(Pouch.ALL);
        bank.depositAll();
        for (byte b = 0; b < 15 && invBefore >= inventory.getCount(); b++)
            sleep(100, 125);
        for (byte b = 0; b < 5 && !inventory.contains(FIRE_RUNE_ID); b++) {
            bank.withdraw(FIRE_RUNE_ID, 0);
            sleep(250, 300);
        }
        int[] pouchIds = {};
        for (PouchType p : pouches.keySet())
            pouchIds = mergeArrays(pouchIds, p.ids);
        for (byte b = 0; b < 5 && inventory.getCount(Pouch.ALL) < pouchesBefore; b++) {
            for (RSItem item : bank.getItems())
                if (item != null)
                    for (int id : pouchIds)
                        if (item.getID() == id)
                            if (bank.withdraw(item.getID(), 1))
                                sleep(250, 300);
        }

        // Paint.runsMade++; TODO
    }

    /**
     * Tries to open the bank if the bank is not open, then tries to withdraw
     * the item
     *
     * @param id
     *            the item to withdraw
     * @param amount
     *            the amount to withdraw, 0 for all
     * @return boolean successfully withdraw
     */
    public boolean withdrawItem(int id, int amount) {
        if (!openBank())
            return false;
        boolean returns = bank.withdraw(id, amount);
        sleep(250, 500);
        return returns;
    }

    /**
     * Withdraws pure essence
     *
     * @return boolean did withdraw item
     */
    public boolean withdrawEss() {
        return withdrawItem(PURE_ESS_ID, 0);
    }

    /**
     * Gets the count of items by the provided id(s) in both the bank and
     * inventory. Includes stack sizes
     *
     * @param id
     *            item ids to search
     * @return int number of items in bank and inventory
     */
    public int getCountBankInv(int... id) {
        int count = 0;
        if (bank.isOpen())
            count += bank.getCount(id);
        count += inventory.getCount(true, id);
        return count;
    }

    /**
     * Emptys pouches using the method set in the Options class
     */
    public void emptyPouches() {
        if (game.getCurrentTab() == Game.TAB_INVENTORY)
            updatePouches();
        for (PouchType pType : pouches.keySet()) {
            if (inventory.isFull())
                break;
            if (inventory.containsOneOf(pType.ids)) {
                if (pouches.get(pType).equals(PouchState.Full)) {
                    RSItem item = inventory.getItem(pType.ids);
                    if (item != null) {
                        int invCount = inventory.getCount();
                        if (item.doAction("Empty"))
                            switch (Options.pouchCheckSystem) {
                            case SERVER_MSG:
                                for (int i = 0; i < POUCH_TRIES; i++) {
                                    if (serverMsg != null)
                                        if (serverMsg
                                                .contains("pouch has no ess")
                                                || serverMsg
                                                        .contains("are no essences in your pouch")) {
                                            pouches.put(pType, PouchState.Empty);
                                            serverMsg = "";
                                            break;
                                        }
                                    sleep(80, 120);
                                }
                                break;
                            case INVENTORY_STATUS:
                                for (int i = 1; i <= POUCH_TRIES; i++)
                                    if (inventory.getCount() == invCount
                                            && i != POUCH_TRIES)
                                        sleep(100, 150);
                                    else {
                                        if (!inventory.isFull())
                                            pouches.put(pType, PouchState.Empty);
                                        break;
                                    }

                                break;
                            }
                    }
                }
            }
        }
    }

    /**
     * Fills pouches using the method set in the Options class
     */
    public void fillPouches() {
        if (game.getCurrentTab() == Game.TAB_INVENTORY)
            updatePouches();
        for (PouchType pType : pouches.keySet()) {
            if (!inventory.contains(PURE_ESS_ID))
                break;
            if (inventory.containsOneOf(pType.ids)) {
                if (pouches.get(pType).equals(PouchState.Empty)) {
                    RSItem item = inventory.getItem(pType.ids);
                    if (item != null) {
                        int invCount = inventory.getCount();
                        if (item.doAction("Fill"))
                            switch (Options.pouchCheckSystem) {
                            case SERVER_MSG:
                                for (int i = 0; i < POUCH_TRIES; i++) {
                                    if (serverMsg != null)
                                        if (serverMsg.contains("pouch is ful")) {
                                            pouches.put(pType, PouchState.Full);
                                            serverMsg = "";
                                            break;
                                        }
                                    sleep(80, 120);
                                }
                                break;
                            case INVENTORY_STATUS:
                                for (int i = 1; i <= POUCH_TRIES; i++)
                                    if (inventory.getCount() == invCount
                                            && i != POUCH_TRIES)
                                        sleep(100, 150);
                                    else {
                                        if (inventory.contains(PURE_ESS_ID))
                                            pouches.put(pType, PouchState.Full);
                                        break;
                                    }

                                break;
                            }
                    }
                }
            }
        }
    }

    /**
     * Rechecks pouches with the inventory's current contents. If a pouch in the
     * list no longer exists it removes it, if there's a pouch in the inventory
     * not in the list it adds it as an empty pouch
     */
    public void updatePouches() {
        for (PouchType pouch : PouchType.values())
            if (inventory.containsOneOf(pouch.ids)) {
                if (!pouches.containsKey(pouch))
                    pouches.put(pouch, PouchState.Empty);
            } else if (pouches.containsKey(pouch))
                pouches.remove(pouch);
    }

    public int getRuneCount(boolean cache) {
        int count = 0;
        for (RSItem i : cache ? inventory.getCachedItems() : inventory
                .getItems())
            if (i.getName() != null
                    && i.getName().toLowerCase().contains("rune"))
                count += i.getStackSize();
        return count;
    }

    /**
     * Crafts essence at the alter
     */
    public void craftEssence() {
        if (alterMeshPath.hasPath())
            alterMeshPath.clearPath();
        if (!bankMeshPath.hasPath())
            bankMeshPath.findPath();

        RSObject alter = objects.getNearest(ZMI_ALTAR_ID);
        if (!alter.isOnScreen()
                && (!getMyPlayer().isMoving()
                        || walking.getDestination() == null || calc
                        .distanceBetween(
                                alter.getArea().getNearestTile(
                                        getMyPlayer().getLocation()),
                                walking.getDestination()) > 2))
            walking.walkTileMM(alter.getArea().getNearestTile(
                    getMyPlayer().getLocation()));

        //int invBefore = inventory.getCount(PURE_ESS_ID);
        //int runesBefore = getRuneCount(false);
        alter.doAction("Craft-rune");
        sleep(1000);
        for (byte b = 0; b < 50
                && (getMyPlayer().getAnimation() == CRAFT_RUNE_ANIM
                        || getMyPlayer().isMoving() || walking.getDestination() != null); b++)
            sleep(100, 125);

        // Paint.essUsed += invBefore - inventory.getCount(PURE_ESS_ID); TODO
        // Paint.runesMade += getRuneCount(false) - runesBefore;
    }

    public boolean onStart() {
        if (game.getCurrentTab() != Game.TAB_MAGIC)
            game.openTab(Game.TAB_MAGIC);
        Options.onLunars = magic.getInterface() != null
                && magic.getInterface().getIndex() == Magic.Book.LUNAR
                        .getInterfaceID();
        Options.tryOuraniaTeleport = (skills.getCurrentLevel(Skills.MAGIC) >= 71 && Options.onLunars);

        pathTypeCurrent = Options.pathType;
        // Set up path:
        if (Options.pathType.equals(OptionsClass.Path.Danger))
            alterMeshPath = new MeshPath(DANGER_MESH);
        else
            alterMeshPath = new MeshPath(SAFE_MESH);
        bankMeshPath = alterMeshPath.reverse();

        // Set up the pouches:
        updatePouches();

        RSItem wep = equipment.getItem(Equipment.WEAPON);
        if (wep != null) {
            Options.hasAirStaff = (wep.getName().toLowerCase()
                    .contains("staff") && wep.getName().toLowerCase()
                    .contains("air"));
            Options.hasEarthStaff = (wep.getName().toLowerCase()
                    .contains("staff") && (wep.getName().toLowerCase()
                    .contains("earth")
                    || wep.getName().toLowerCase().contains("mud") || wep
                    .getName().toLowerCase().contains("lava")));
        }

        new DataLoader(this);

        // optimal alt
        camera.setPitch(random(0, 10));

        log.info("Script initiation successful!");
        log.info("--Setup--");
        log.info("Air staff: " + (Options.hasAirStaff ? "yes" : "no"));
        log.info("Earth staff: " + (Options.hasEarthStaff ? "yes" : "no"));
        log.info("Walking range: " + Options.walkingDistance.toString());
        log.info("Pouch method: "
                + PaintFormatter.properCaseAll(Options.pouchCheckSystem.name()
                        .replaceAll("_", " ")));
        log.info("Pouch repair system: "
                + PaintFormatter.properCaseAll(Options.pouchRepair.name()
                        .replaceAll("_", " ")));
        log.info("Walking style: "
                + PaintFormatter.properCaseAll(Options.pathType.name()));
        log.info("Recharge Energy: "
                + (Options.chargeEnergy ? "True" : "False"));
        log.info("Try Ourania Teleport: "
                + (Options.tryOuraniaTeleport ? "True" : "False"));
        return true;
    }

    public boolean isResting() {
        int anim = getMyPlayer().getAnimation();
        return (anim == 12108 || anim == 2033 || anim == 2716 || anim == 11786 || anim == 5713);
    }

    public void rest() {
        for (int d = 0; d < 5; d++) {
            interfaces.getComponent(walking.INTERFACE_RUN_ORB, 1).doAction(
                    "Rest");
            mouse.moveSlightly();
            sleep(random(400, 600));
            int anim = players.getMyPlayer().getAnimation();
            if (anim == 12108 || anim == 2033 || anim == 2716 || anim == 11786
                    || anim == 5713) {
                break;
            }
        }
    }

    public int loop() {
        mouse.setSpeed(random(4, 6));
        if (!walking.isRunEnabled() && walking.getEnergy() > 50 && !isResting())
            walking.setRun(true);
        try {
            currentState = getState();
            switch (currentState) {
            case LADDER_DOWN:
                if (objects.getNearest(LADDER_ID).isOnScreen())
                    if (objects.getNearest(LADDER_ID).doAction("Climb"))
                        sleep(500, 750);
                break;
            case OURANIA_TELEPORT:
                if (magic.castSpell(Magic.SPELL_OURANIA_TELEPORT))
                    for (byte b = 0; b < 30 && !calc.tileOnMap(OURANIA_PATH[0]); b++)
                        sleep(100, 125);
                sleep(500, 750);
                break;
            case TRAVERSE_OURANIA:
                RSTilePath tPath = walking.newTilePath(OURANIA_PATH).randomize(
                        2, 2);
                for (byte b = 0; b < 300 && tPath.isValid()
                        && (objects.getNearest(LADDER_ID) != null) ? !objects
                        .getNearest(LADDER_ID).isOnScreen() : true; b++) {
                    tPath.traverse();
                    sleep(95, 105);
                }
                break;
            case CHARGE_ENERGY:
                if (!isResting())
                    rest();
                if (isResting())
                    while (walking.getEnergy() < 100 && isResting()
                            && isActive())
                        sleep(200);
                break;
            case NEAR_BANK:
                RSNPC banker = npcs.getNearest(BANKER_ID);
                if (banker != null)
                    if (!banker.isOnScreen()) {
                        RSTile loc = banker.getLocation();
                        if (calc.tileOnMap(loc)) {
                            walking.walkTileMM(loc);
                            for (byte b = 0; b < 22 && !banker.isOnScreen(); b++)
                                sleep(100, 115);
                        }
                    }
                break;
            case BANK_DEPOSIT:
                deposit();
                break;
            case BANK_WITHDRAW:
                withdrawEss();
                break;
            case CRAFT_RUNES:
                craftEssence();
                break;
            case EMPTY_POUCHES:
                emptyPouches();
                break;
            case EAT_FOOD:
                if (!inventory.containsOneOf(food)) {
                    openBank();
                    for (int id : food)
                        if (bank.getCount(id) > 0)
                            if (bank.withdraw(id, 1))
                                break;
                }
                if (bank.isOpen())
                    bank.close();
                if (inventory.containsOneOf(food)) {
                    RSItem foodI = inventory.getItem(food);
                    if (foodI != null)
                        foodI.doAction("Eat");
                }
                break;
            case FILL_POUCHES:
                fillPouches();
                break;
            case NPC_CONTACT:
                npcContact.main();
                break;
            case TRAVERSE_BANK:
                if (!bankMeshPath.hasPath())
                    bankMeshPath.findPath(MeshPathType.FULL);
                if (Options.pathType.equals(OptionsClass.Path.Safe)
                        && (bankMeshPath.getNearestByPath() == null || !bankMeshPath
                                .getNearestByPath().equals(
                                        bankMeshPath.getEnd())))
                    if (objects.getNearest(CRACK_OUT) != null
                            && objects.getNearest(CRACK_OUT).isOnScreen()
                            && objects.getNearest(CRACK_OUT).doAction(
                                    "Squeeze-through")) {
                        sleep(500);
                        for (byte b = 0; b < 20
                                && getMyPlayer().getAnimation() != -1; b++)
                            sleep(100, 110);
                        break;
                    }
                bankMeshPath.traverse();
                break;
            case TRAVERSE_ALTER:
                if (!alterMeshPath.hasPath())
                    alterMeshPath.findPath(MeshPathType.ALL_CENTER);
                if ((calc.pathLengthTo(alterDet, true) > 25 || calc
                        .pathLengthTo(alterDet, true) < 0)
                        && Options.pathType.equals(OptionsClass.Path.Safe))
                    if (objects.getNearest(CRACK_IN) != null)
                        if (objects.getNearest(CRACK_IN).isOnScreen()
                                && objects.getNearest(CRACK_IN).doAction(
                                        "Squeeze-through")) {
                            sleep(500);
                            for (byte b = 0; b < 20
                                    && getMyPlayer().getAnimation() != -1; b++)
                                sleep(100, 110);
                            break;
                        }
                alterMeshPath.traverse();
                break;
            }
        } catch (Exception e) {
            logError(e);
        }
        return random(50, 100);
    }

    public void onFinish() {
        FailSafe();
        // Paint.paintMenu.saveProggie();
    }

    /**
     * Logs an exception to the Logger and to the error cache
     *
     * @param e
     *            as the Exception to log
     */
    public void logError(Exception e) {
        String s = e.getMessage();
        log.severe(s);
        for (StackTraceElement ele : e.getStackTrace()) {
            s += "\n" + ele.toString();
            log.severe(ele.toString());
        }
    }

    /**
     * {@inheritDoc}
     */
    public void onRepaint(Graphics g1) {
        Graphics2D g = (Graphics2D) g1;
        try {
            // MeshPaths
            alterMeshPath.paintAll(g);
            if (bankMeshPath.hasPath()) {
                bankMeshPath.paintPath(g);
            }
        } catch (NullPointerException e) {
            logError(e);
        }
    }

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

    /**
     * The different states the NPC contact process can be in
     *
     * @author Equinox_
     *
     */
    enum npcContactState {
        CAST, SCROLL, SELECT, WAIT, CONTINUE, MENU, WITHDRAW_ASTRAL, WITHDRAW_COSMIC, WITHDRAW_AIR, OUT_OF_RUNES
    }

    /**
     * A class to contact people using NPC contact
     *
     * @author Equinox_
     *
     */
    class NPCContact {
        public npcContactState currentState = npcContactState.WAIT;
        private final int MAIN_FRAME = 88;
        private final int SCROLL_BAR = 20;
        private final int SCROLL_BAR_DOWN = 0;
        private final int VISIBLE_NPCS_CONTAINER = 21;
        private final int NPCS_CONTAINER = 22;
        private final int NPC_CONTACT_ANIM = 4413;

        private final int NPC_TO_SELECT = 14;
        private final String[] MENU_ITEM = { "repair", "pouch" };

        /**
         * Gets the current npcContactState
         *
         * @return the current npcContactState
         */
        private npcContactState getState() {
            if (interfaces.get(MAIN_FRAME).isValid()) {
                if (interfaces.get(MAIN_FRAME).getComponent(NPCS_CONTAINER)
                        .isValid()) {
                    Point npcPoint = interfaces.get(MAIN_FRAME)
                            .getComponent(NPCS_CONTAINER)
                            .getComponent(NPC_TO_SELECT).getCenter();
                    Rectangle visible = interfaces.get(MAIN_FRAME)
                            .getComponent(VISIBLE_NPCS_CONTAINER).getArea();
                    if (!visible.contains(npcPoint))
                        return npcContactState.SCROLL;
                    else
                        return npcContactState.SELECT;
                }
            }

            if (interfaces.canContinue())
                return npcContactState.CONTINUE;

            if (getComponent(MENU_ITEM) != null)
                return npcContactState.MENU;

            if (!interfaces.canContinue()
                    && getMyPlayer().getAnimation() != NPC_CONTACT_ANIM
                    && getComponent(MENU_ITEM) == null
                    && getComponent("lease wai") == null) {
                if (!inventory.contains(ASTRAL_RUNE_ID))
                    return npcContactState.WITHDRAW_ASTRAL;
                if (!inventory.contains(COSMIC_RUNE_ID))
                    return npcContactState.WITHDRAW_COSMIC;
                if (inventory.getCount(true, AIR_RUNE_ID) < 2
                        && !Options.hasAirStaff)
                    return npcContactState.WITHDRAW_AIR;
                return npcContactState.CAST;
            }
            return npcContactState.WAIT;
        }

        /**
         * Finds a RSComponent with the specified string
         *
         * @param s
         *            The String to search
         * @return RSComponent with string, otherwise null
         */
        private RSComponent getComponent(String... s) {
            RSInterface[] valid = interfaces.getAll();
            for (RSInterface iface : valid) {
                if (iface.getIndex() != 137) {
                    int len = iface.getChildCount();
                    for (int i = 0; i < len; i++) {
                        RSComponent child = iface.getComponent(i);
                        boolean b = (child.isValid()
                                && child.getAbsoluteX() > 10 && child
                                .getAbsoluteY() > 300);
                        for (String sub : s)
                            if (!child.getText().toLowerCase()
                                    .contains(sub.toLowerCase()))
                                b = false;
                        if (b)
                            return child;
                    }
                }
            }
            return null;
        }

        /**
         * Checks if the inventory or bank contains the specified item
         *
         * @param id
         *            the item id
         * @return <tt>true</tt> if the bank or inventory contains the item,
         *         otherwise, <tt>false</tt>
         */
        boolean invBank(int id) {
            return bank.getCount(id) > 0 || inventory.containsOneOf(id);
        }

        /**
         * Gets the count of a specified item in the inventory and bank
         *
         * @param int itemId
         * @return the item count
         */
        int invBankCount(int id) {
            return bank.getCount(id) + inventory.getCount(true, id);
        }

        /**
         * The main loop. Call this to do the next action for the contact
         * process.
         */
        public void main() {
            switch (currentState = getState()) {
            case WITHDRAW_ASTRAL:
                withdrawItem(ASTRAL_RUNE_ID, 1);
                if (!invBank(ASTRAL_RUNE_ID))
                    removePouches();
                break;
            case WITHDRAW_COSMIC:
                withdrawItem(COSMIC_RUNE_ID, 1);
                if (!invBank(COSMIC_RUNE_ID))
                    removePouches();
                break;
            case WITHDRAW_AIR:
                if (!inventory.contains(AIR_RUNE_ID)) {
                    if (inventory.isFull())
                        bank.deposit(PURE_ESS_ID, 1);
                    withdrawItem(AIR_RUNE_ID, 1);
                }
                withdrawItem(AIR_RUNE_ID, 1);
                if (invBankCount(AIR_RUNE_ID) < 2)
                    removePouches();
                break;
            case CAST:
                for (byte b = 0; b < 5; b++)
                    if (bank.isOpen()) {
                        bank.close();
                        for (byte b2 = 0; b2 < 25; b2++)
                            if (bank.isOpen())
                                break;
                            else
                                sleep(95, 115);
                    }
                if (game.getCurrentTab() != Game.TAB_MAGIC)
                    game.openTab(Game.TAB_MAGIC);

                sleep(500, 1250);
                magic.castSpell(Magic.SPELL_NPC_CONTACT);
                sleep(750, 1250);
                break;
            case SCROLL:
                // Scroll
                RSComponent bar = interfaces.get(MAIN_FRAME)
                        .getComponent(SCROLL_BAR).getComponent(SCROLL_BAR_DOWN);
                Point p = bar.getCenter();
                p.y = bar.getAbsoluteY() + bar.getHeight() - 5;
                mouse.click(p, true);
                break;
            case SELECT:
                interfaces.get(MAIN_FRAME).getComponent(NPCS_CONTAINER)
                        .getComponent(NPC_TO_SELECT).doClick();
                break;
            case WAIT:
                break;
            case CONTINUE:
                if (interfaces.canContinue())
                    interfaces.clickContinue();
                break;
            case MENU:
                if (getComponent(MENU_ITEM) != null)
                    getComponent(MENU_ITEM).doClick();
                break;
            }
            sleep(900, 1200);
        }

        public void removePouches() {
            if (!openBank())
                return;
            // not enough runes, bank pouches:
            for (int id : Pouch.ALL_DEGRADED)
                if (inventory.contains(id)) {
                    if (bank.deposit(id, 1))
                        sleep(500, 600);
                }
            updatePouches();
        }
    }

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

        public DataLoader(EquinoxZMICrafter crafter) {
            super("Data Loader");
            this.crafter = crafter;
            this.start();
        }

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

        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();
                 * crafter.Paint.putImage( "homeicon", ImageIO.read(new
                 * URL(crafter.baseURL + "/images/houseIcon.png")));
                 * crafter.log("Loaded home image in " +
                 * PaintFormatter.getFormattedTime(System .currentTimeMillis() -
                 * before));
                 *
                 * before = System.currentTimeMillis(); crafter.Paint .putImage(
                 * "rcicon", ImageIO.read(new URL(
                 * "http://www.runescape.com/img/hiscores/skill_icon_Runecrafting1.gif"
                 * ))); crafter.log("Loaded runecrafting image in " +
                 * PaintFormatter.getFormattedTime(System .currentTimeMillis() -
                 * before));
                 *
                 * before = System.currentTimeMillis(); crafter.Paint.putImage(
                 * "toolsicon", ImageIO.read(new URL(crafter.baseURL +
                 * "/images/tools.png"))); crafter.log("Loaded tools icon in " +
                 * PaintFormatter.getFormattedTime(System .currentTimeMillis() -
                 * before));
                 */
            } catch (Exception e) {
                crafter.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;
    }

    public void FailSafe() {
        log.info("FailSafe Activated!");

        // Set up path:
        if (pathTypeCurrent.equals(OptionsClass.Path.Danger))
            alterMeshPath = new MeshPath(DANGER_MESH);
        else
            alterMeshPath = new MeshPath(SAFE_MESH);
        bankMeshPath = alterMeshPath.reverse();
        if (!bankMeshPath.hasPath())
            bankMeshPath.findPath(MeshPathType.FULL);
        while (bankMeshPath.isValid()
                && calc.distanceTo(bankMeshPath.getEnd()) >= 2) {
            if (Options.pathType.equals(OptionsClass.Path.Safe)
                    && (bankMeshPath.getNearestByPath() == null || !bankMeshPath
                            .getNearestByPath().equals(bankMeshPath.getEnd())))
                if (objects.getNearest(CRACK_OUT) != null
                        && objects.getNearest(CRACK_OUT).isOnScreen()
                        && objects.getNearest(CRACK_OUT).doAction(
                                "Squeeze-through")) {
                    sleep(500);
                    for (byte b = 0; b < 20
                            && getMyPlayer().getAnimation() != -1; b++)
                        sleep(100);
                    continue;
                }

            bankMeshPath.traverse();

        }
        log.info("Failsafe Complete");
    }
}