[Request]Tenac's Guild Miner.

Can someone plz post the lastest version of Tenacs guild miner? Thanks in advance.

 

I'll request this too.

 

Here it is, this is 2.1, idk if it is the newest, can anyone confirm that 2.1 is the newest?

Code:

import java.awt.*;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;

import com.speljohan.rsbot.bot.*;
import com.speljohan.rsbot.script.*;
import com.speljohan.rsbot.accessors.*;
import com.speljohan.rsbot.script.wrappers.*;
import com.speljohan.rsbot.event.listeners.*;

public class TenacGuildMiner extends Script implements PaintListener {

    int[] bankerID = { 6200 };
    int[] bankBoothID = { 11758 };
        
    RSTile topLadderObjectTile = new RSTile(3019, 3339);
    int[] ladderID = { 30941 };
    int[] coalRockID = { 31068, 31069, 31070 };
    int[] mithRockID = { 31086, 31087, 31088 };

    int coalID = 453;
    int mithrilID = 447;
    int[] gemID = { 1617, 1619, 1621, 1623 };
    int[] pickaxeHandleID = { 466 };
    int[] pickaxeID = { 1265, 1267, 1269, 1273, 1271, 1275 };
    int[] pickaxeHeadID = { 480, 482, 484, 486, 488, 490 };
    int[] brokenPickaxeID =  { 468, 470, 472, 474, 476, 478 };
    
    int[] junkItems = { 1917, 1971 }; //beer, kebab
    int goldPiecesID = 995;

    RSTile lumbridgeTile = new RSTile(3221, 3218);

    RSTile bankTile = new RSTile(3014, 3356);
    RSTile[] betweenBankAndLadderTiles = { new RSTile(3019, 3351), new RSTile(3022, 3351), new RSTile(3024, 3352) };
    RSTile ladderTile = new RSTile(3021, 3341);
    //RSTile[] topLadderTiles = { new RSTile(3022, 3341), new RSTile(3022, 3337) };
    //RSTile[] bottomLadderTiles = { new RSTile(3021, 9741), new RSTile(3022, 9740) };

    RSTile[] coalToLadderPath = { new RSTile(3046, 9752), new RSTile(3044, 9745), new RSTile(3044, 9738),
                                  new RSTile(3037, 9737), new RSTile(3030, 9737), new RSTile(3020, 9739) };

    RSTile[] ladderToCoalPath = { new RSTile(3020, 9739), new RSTile(3030, 9737), new RSTile(3037, 9737),
                                  new RSTile(3044, 9738), new RSTile(3044, 9745), new RSTile(3046, 9752) };

    RSTile[] lumbridgeToFalidorPath = { new RSTile(3226, 3218), new RSTile(3233, 3220), new RSTile(3233, 3225),
                                        new RSTile(3231, 3230), new RSTile(3228, 3233), new RSTile(3223, 3238),
                                        new RSTile(3221, 3242), new RSTile(3219, 3247), new RSTile(3218, 3251),
                                        new RSTile(3217, 3256), new RSTile(3217, 3257), new RSTile(3217, 3261),
                                        new RSTile(3217, 3266), new RSTile(3216, 3272), new RSTile(3216, 3277),
                                        new RSTile(3210, 3280), new RSTile(3205, 3280), new RSTile(3204, 3279),
                                        new RSTile(3197, 3279), new RSTile(3190, 3282), new RSTile(3184, 3286),
                                        new RSTile(3178, 3287), new RSTile(3172, 3286), new RSTile(3165, 3285),
                                        new RSTile(3158, 3291), new RSTile(3149, 3296), new RSTile(3143, 3294),
                                        new RSTile(3137, 3295), new RSTile(3136, 3295), new RSTile(3130, 3295),
                                        new RSTile(3123, 3299), new RSTile(3118, 3296), new RSTile(3112, 3295),
                                        new RSTile(3106, 3295), new RSTile(3099, 3295), new RSTile(3094, 3292),
                                        new RSTile(3088, 3290), new RSTile(3082, 3289), new RSTile(3076, 3288),
                                        new RSTile(3074, 3284), new RSTile(3074, 3280), new RSTile(3069, 3277),
                                        new RSTile(3063, 3277), new RSTile(3057, 3276), new RSTile(3050, 3276),
                                        new RSTile(3047, 3276), new RSTile(3044, 3274), new RSTile(3037, 3277),
                                        new RSTile(3030, 3278), new RSTile(3024, 3276), new RSTile(3018, 3275),
                                        new RSTile(3013, 3276), new RSTile(3011, 3278), new RSTile(3007, 3284),
                                        new RSTile(3004, 3289), new RSTile(3007, 3294), new RSTile(3006, 3299),
                                        new RSTile(3004, 3304), new RSTile(3006, 3310), new RSTile(3007, 3316),
                                        new RSTile(3007, 3321), new RSTile(3005, 3326), new RSTile(3007, 3331),
                                         new RSTile(3007, 3332), new RSTile(3007, 3337), new RSTile(3007, 3343),
                                         new RSTile(3007, 3349), new RSTile(3005, 3355), new RSTile(3007, 3361),
                                         new RSTile(3012, 3361), new RSTile(3015, 3355) };

    long startTime = System.currentTimeMillis();
    int startingLevel = skills.getCurrentSkillLevel(STAT_MINING);
    int startingExperience = skills.getCurrentSkillExp(STAT_MINING);
    int oldExperience = 0;
    int ranAwayFromCombat = 0;
    int gemsBanked = 0;
    int coalBanked = 0;
    int mithBanked = 0;
    int gemsDropped = 0;
    int coalDropped = 0;
    int mithDropped = 0;
    int xpPerCoal = 50;
    int xpPerMithril = 80;
    int energyToRunAt = random(40, 90);

    boolean powermine = false;
    int invCountToDrop = random(10, 29);
    boolean dropping = false;
    
    boolean walkBack = false;
    boolean miningMith = false;
    boolean runAway = false;
    boolean needNewPick = false;

    int priceOfCoal = getMarketPriceOfItem(coalID);
    int priceOfMithril = getMarketPriceOfItem(mithrilID);

    public double getVersion() {
        return 2.1;
    }

    public String getName() {
        return "Tenac's Guild Miner";
    }

    public String getAuthor() {
        return "Tenac";
    }

    public String getScriptCategory() {
        return "Mining";
    }

    public String getScriptDescription( ) {
        String html = "";

        html += "<html>\n";
        html += "<body>\n";

        html += "<font size=\"6\">";
        html += "<center><h2>" + getName() + "</h2></center>\n";
        html += "</font>";

        html += "<b>Author:</b>" + getAuthor() + "<br/>";
        html += "<b>Version:</b>" + getVersion() + "<br/><br>";

        html += "Start anywhere with a pickaxe and at least 60 mining, preferably inside Falidor East bank or Mining Guild.<br>\n<br>";
        
        html += "<input type=\"checkbox\" name=\"mineMith\" value=\"yes\">Mine mithril rocks also?\n<br>";
        html += "<input type=\"checkbox\" name=\"powermine\" value=\"yes\">Drop ores?\n<br>";
        
        html += "</body>\n";
        html += "</html\n";

        return html;
    }

    public boolean onStart(Map<String, String> args) {
        startTime = System.currentTimeMillis();
        if(isLoggedIn()) {
            startingLevel = skills.getCurrentSkillLevel(STAT_MINING);
            startingExperience = skills.getCurrentSkillExp(STAT_MINING);
            setCameraAltitude(true);
            setCameraRotation(random(1, 359));
        }

        if(args.get("mineMith") != null)
            miningMith = true;

        if(args.get("powermine") != null)
            powermine = true;

        Bot.getEventManager().addListener(PaintListener.class, this);
        return true;
    }

    public void onFinish() {
        Bot.getEventManager().removeListener(PaintListener.class, this);
    }

    int height = 1;

    public void onRepaint(Graphics g) {
        if(isLoggedIn()) {
            if(startTime == 0)
                startTime = System.currentTimeMillis();

            if(startingLevel == 0 || startingExperience == 0) {
                startingLevel = skills.getCurrentSkillLevel(STAT_MINING);
            }

            long millis = System.currentTimeMillis() - startTime;
            long hours = millis / (1000 * 60 * 60);
            millis -= hours * (1000 * 60 * 60);
            long minutes = millis / (1000 * 60);
            millis -= minutes * (1000 * 60);
            long seconds = millis / 1000;

            g.setColor(new Color(33, 46, 207, 100));
            //window is (0, 0) (337, 515)
            //my box is (515 - 260, 0) (337, 200)
            int x = 515 - 230;
            int y = 4;
            g.fillRoundRect(x, y, 230, height, 20, 20);
            g.setColor(new Color(26, 36, 162, 255));
            g.drawRoundRect(x, y, 230, height, 20, 20);
            
            g.setColor(new Color(255, 255, 255, 255));
            g.drawString("Tenac's Guild Miner v" + getVersion(), x + 10, y += 15);
            g.drawString("Running for " + hours + ":" + minutes + ":" + seconds, x + 10, y += 15);
            if(powermine) {
                g.drawString("Dropped " + coalDropped + " coal", x + 10, y += 15);
                g.drawString("Dropped " + mithDropped + " mithril", x + 10, y += 15);
                g.drawString("Dropped " + gemsDropped + " gems", x + 10, y += 15);
            } else {
                g.drawString("Banked " + coalBanked + " coal", x + 10, y += 15);
                g.drawString("Banked " + mithBanked + " mithril", x + 10, y += 15);
                g.drawString("Banked " + gemsBanked + " gems", x + 10, y += 15);
            }
            if(!powermine) {
                g.drawString("Gained " + ((coalBanked * priceOfCoal) + (mithBanked * priceOfMithril)) + "gp", x + 10, y += 15);
                //averaging __gp per hour
            }
            g.drawString("Currently level " + skills.getCurrentSkillLevel(STAT_MINING) + " and " + skills.getPercentToNextLevel(STAT_MINING) + "% to next level", x + 10, y += 15);
            g.drawString("Gained " + (skills.getCurrentSkillLevel(STAT_MINING) - startingLevel) + " levels", x + 10, y += 15);
            //___ until level (skills.getCurrentSkillLevel(STAT_MINING) + 1)
            g.drawString("Gained " + (skills.getCurrentSkillExp(STAT_MINING) - startingExperience) + " experience", x + 10, y += 15);
            //averaging ____ experience per hour
            g.drawString("Ran from combat " + ranAwayFromCombat + " times", x + 10, y += 15);
            g.drawString("" + (int)(skills.getXPToNextLevel(STAT_MINING) / xpPerCoal + 1) + " more coal until next level", x + 10, y += 15);
            height = y + 3;
        }
    }

    public void printProgressReport() {
        if(startTime == 0)
            startTime = System.currentTimeMillis();
        if(startingLevel == 0 || startingExperience == 0) {
            startingLevel = skills.getCurrentSkillLevel(STAT_MINING);
            startingExperience = skills.getCurrentSkillExp(STAT_MINING);
        }
        long millis = System.currentTimeMillis() - startTime;
        long hours = millis / (1000 * 60 * 60);
        millis -= hours * (1000 * 60 * 60);
        long minutes = millis / (1000 * 60);
        millis -= minutes * (1000 * 60);
        long seconds = millis / 1000;
        log("Tenac's Guild Miner v" + getVersion());
        log("Running for " + hours + ":" + minutes + ":" + seconds);
        if(powermine) {
            log("Dropped " + coalDropped + " coal");
            log("Dropped " + mithDropped + " mithril");
            log("Dropped " + gemsDropped + " gems");
        } else {
            log("Banked " + coalBanked + " coal");
            log("Banked " + mithBanked + " mithril");
            log("Banked " + gemsBanked + " gems");
        }
        if(!powermine) {
            log("Gained " + ((coalBanked * priceOfCoal) + (mithBanked * priceOfMithril)) + "gp");
            //averaging __gp per hour
        }
        log("Currently level " + skills.getCurrentSkillLevel(STAT_MINING) + " and " + skills.getPercentToNextLevel(STAT_MINING) + "% to next level");
        log("Gained " + (skills.getCurrentSkillLevel(STAT_MINING) - startingLevel) + " levels");
        //___ until level (skills.getCurrentSkillLevel(STAT_MINING) + 1)
        log("Gained " + (skills.getCurrentSkillExp(STAT_MINING) - startingExperience) + " experience");
        //averaging ____ experience per hour
        log("Ran from combat " + ranAwayFromCombat + " times");
        log("" + (int)(skills.getXPToNextLevel(STAT_MINING) / xpPerCoal + 1) + " more coal until next level");
    }

    public int getMarketPriceOfItem(int id) {
        String pageSource = "";
        int begin = 0;
        int end = 0;
        try {
            URL theUrl = new URL("http://itemdb-rs.runescape.com/viewitem.ws?obj=" + id);
            URLConnection theUrlConnection = theUrl.openConnection();
            BufferedReader in = new BufferedReader(new InputStreamReader(theUrlConnection.getInputStream()));
            String inputLine = "";
            while ((inputLine = in.readLine()) != null)
                pageSource += inputLine;
            in.close();
            pageSource = pageSource.replaceAll("\n", "");
            pageSource = pageSource.replaceAll("\t", "");
            begin = pageSource.indexOf("<b>Market price:</b> ") + ("<b>Market price:</b> ").length();
            end = pageSource.indexOf("</span><span><b>Maximum price:</b>");
        } catch (Exception e) {
            System.out.println("Error obtaining price of http://itemdb-rs.runescape.com/viewitem.ws?obj=" + id);
        }
        return (int)new Integer(pageSource.substring(begin, end)).intValue();
    }

    public int loop() {
        if(!isLoggedIn())
            return random(500, 800);

        //if(getGroundItemByID(17, pickaxeHeadID) != null && (isCarryingItem(pickaxeHandleID)))
        if(getGroundItemByID(17, pickaxeHeadID) != null)
            return fixPickaxe();
        
        if(getEnergy() >= energyToRunAt) {
            energyToRunAt = random(40, 90);
            setRun(true);
        }
        
        if(getMyPlayer().isInCombat())
            runAway = true;
        
        if(runAway)
            return runAway();
        
        if(distanceTo(lumbridgeTile) <= 17)
            walkBack = true;

        if(isLost()) {
            if(myGetNextTile(lumbridgeToFalidorPath, 17) == null)
                return teleportToLumbridge();
            walkBack = true;
        }

        if(walkBack) {
            if(myWalkPath(lumbridgeToFalidorPath, 17, 1)) {
                walkBack = false;
                return depositInventory();
            }
        }

/*
        //will never be called since the  rsbot equipment interface is fucked up
        if(isCarryingItem(brokenPickaxeID) || isCarryingItem(pickaxeHandleID) || !isCarryingItem(pickaxeID))
            return getNewPick();
*/

        if(getInterface(211).isValid())
            if(getInterface(211).getChild(1).containsText("You need a Pickaxe") && getGroundItemByID(17, pickaxeHeadID) == null)
                needNewPick = true;
        
        if(needNewPick) {
            if(getNewPick() == 99999) {
                needNewPick = false;
                return random(10, 20);
            } else {
                return random(10, 20);
            }
        }

        if(isCarryingJunk())
            return dropJunk();

        if(canEquipPickaxe())
            return wieldPickaxe();

        if(powermine && (getInventoryCount() >= invCountToDrop || isInventoryFull()))
            dropping = true;

        if(dropping)
            return dropInventory();

        if(isInventoryFull() && !powermine)
            return depositInventory();

        if(isInventoryFull())
            return depositInventory();

        return mineCoal();
    }

    public boolean isLost() {
        if(distanceTo(lumbridgeTile) <= 17)
                return false;
        if(distanceTo(bankTile) <= 17)
            return false;
        if(distanceTo(ladderTile) <= 17)
            return false;
        for(int i = 0; i < betweenBankAndLadderTiles.length - 1; i++)
            if(distanceTo(betweenBankAndLadderTiles[i]) <= 17)
                    return false;
        for(int i = 0; i < coalToLadderPath.length - 1; i++)
            if(distanceTo(coalToLadderPath[i]) <= 17)
                    return false;
        return true;
    }

    public int dropInventory() {
        if(atInventoryItem(coalID, "Drop")) {
            coalDropped++;
            wait(random(500, 700));
            return random(50, 75);
        } else if(atInventoryItem(mithrilID, "Drop")) {
            mithDropped++;
            wait(random(500, 700));
            return random(50, 75);
        }
        for(int i = 0; i < gemID.length; i++) {
            if(atInventoryItem(gemID[i], "Drop")) {
                gemsDropped++;
                wait(random(500, 700));
                return random(50, 75);
            }
        }
        dropping = false;
        invCountToDrop = random(10, 29);
        return random(50, 75);
    }

    public boolean isCarryingJunk() {
        for(int i = 0; i < junkItems.length; i++) {
            if(inventoryContainsOneOf(junkItems[i])) {
                return true;
            }
        }
        RSItem item = getInventoryItemByID(goldPiecesID);
        if(item != null) {
            if(item.getStackSize() <= 5000) {
                return true;
            }
        }
        return false;
    }
    
    public int dropJunk() {
        for(int i = 0; i < junkItems.length; i++) {
            if(inventoryContainsOneOf(junkItems[i])) {
                if(atInventoryItem(junkItems[i], "Drop"))
                    return random(550, 700);
            }
        }
        RSItem item = getInventoryItemByID(goldPiecesID);
        if(item != null) {
            if(item.getStackSize() <= 5000) {
                if(atInventoryItem(goldPiecesID, "Drop"))
                    return random(550, 700);
            }
        }
        return random(40, 100);
    }
    
    public void unequipWeapon() {
        openTab(TAB_EQUIPMENT);
        RSInterface equip = RSInterface.getInterface(INTERFACE_TAB_EQUIPMENT);
        RSInterfaceChild weapon = equip.getChild(16);
        atInterface(weapon);
        wait(random(400, 800));
        openTab(TAB_INVENTORY);
    }

    public int runAway() {
        log("Running away from combat...");
        setRun(true);
        if(getMyPlayer().getLocation().getY() > 6000) {
            if(!myWalkPath(coalToLadderPath, 17, 2))
                return random(200, 300);
            waitUntilNotMoving();
            if(!climbUpLadder())
                climbUpLadder();
            wait(random(2200, 3400));
        } else {
            RSTile curentTile = getMyPlayer().getLocation();
            int xRand = random(-16, 17);
            int yRand;
            if(random(0, 2) == 0)
                yRand = -(int)(Math.sqrt((16 * 16) - (xRand * xRand)));
            else
                yRand = -(int)(Math.sqrt((16 * 16)- (xRand * xRand)));
            RSTile runawayTile = new RSTile(curentTile.getX() + xRand, curentTile.getY() + yRand);
            myWalkTile(runawayTile, 0);
            waitUntilNearTile(runawayTile, 0);
            wait(random(2200, 3400));
            myWalkTile(curentTile, 1);
            wait(random(50, 600));
            if(random(0, 4) < 3)
                moveMouse(random(100, 415), random(100, 237));
            waitUntilNotMoving();
        }
        runAway = false;
        ranAwayFromCombat++;
        log("Combat evaded.");
        return random(50, 100);
    }

    long upLadderTimer = System.currentTimeMillis();

    public boolean climbUpLadder() {
        upLadderTimer = System.currentTimeMillis();
        RSObject object = getNearestObjectById(16, ladderID);
        if(object == null)
            return false;
        if(!Calculations.onScreen(Calculations.tileToScreen(object.getLocation()))) {
            myWalkTile(object.getLocation(), 2);
            wait(random(50, 600));
            if(random(0, 4) < 3)
                moveMouse(random(100, 415), random(100, 237));
            waitUntilNotMoving();
        }
        if(atObject(object, "up")) {
            while(getMyPlayer().getLocation().getY() > 6000 && System.currentTimeMillis() - upLadderTimer < 6000) {
                if(getMyPlayer().getLocation().getY() < 6000)
                    return true;
                if(System.currentTimeMillis() - upLadderTimer >= 6000)
                    return false;
                wait(random(600, 800));
            }
        } else {
            setCameraRotation(random(1, 359));
            //setCameraAltitude(true);
        }
        return false;
    }

    public boolean atTileModified(RSTile tile, String action) {
        try {
            Point location = Calculations.tileToScreen(tile);
            if (location.x == -1 || location.y == -1) return false;
            int xRand = 0;
            int yRand = 0;
            if(random(0, 2) == 0)
                xRand = random(-26, -16);
            else
                xRand = random(16, 26);
            if(random(0, 2) == 0)
                yRand = random(-26, -16);
            else
                yRand = random(16, 26);
            moveMouse(location, xRand, yRand);
            if (getMenuItems().get(0).toLowerCase().contains(action.toLowerCase())) {
                clickMouse(true);
            } else {
                clickMouse(false);
                if(!atMenu(action))
                    return false;
            }
            waitUntilNotMoving();
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    long downLadderTimer = System.currentTimeMillis();

    public boolean climbDownLadder() {
        downLadderTimer = System.currentTimeMillis();
        if(!Calculations.onScreen(Calculations.tileToScreen(topLadderObjectTile)))
            return false;
        if(atTileModified(topLadderObjectTile, "down")) {
            while(getMyPlayer().getLocation().getY() < 6000 && System.currentTimeMillis() - downLadderTimer < 6000) {
                if(getMyPlayer().getLocation().getY() > 6000)
                    return true;
                if(System.currentTimeMillis() - downLadderTimer >= 6000)
                    return false;
                wait(random(600, 800));
            }
        } else {
            //if(distanceTo(ladderTile) > 6)
            //    myWalkTile(ladderTile, 2);
            setCameraRotation(random(1, 359));
            //setCameraAltitude(true);
            //waitUntilNearTile(ladderTile, 0);
        }
        return false;
    }

    public int getNewPick() {
        if(getMyPlayer().getLocation().getY() > 6000) {
            if(myWalkPath(coalToLadderPath, 15, 3)) {
                waitUntilNotMoving();
                climbUpLadder();
            }
            return random(100, 200);
        }
        if(distanceTo(bankTile) > 4) {
            if(myWalkTile(bankTile, 1)) {
                wait(random(50, 600));
                if(random(0, 4) < 3)
                    moveMouse(random(100, 415), random(100, 237));
                waitUntilNotMoving();
            } else {
                RSTile theTile = betweenBankAndLadderTiles[random(0, betweenBankAndLadderTiles.length)];
                myWalkTile(theTile, 1);
                if(random(0, 2) == 0)
                    setCameraAltitude(true);
                waitUntilNearTile(theTile, 2);
            }
            return random(200, 300);
        }
        if(!RSInterface.getInterface(INTERFACE_BANK).isValid()) {
            int r = random(0, 2);
            if(r == 0)
                if(!atObject(getNearestObjectById(15, bankBoothID), "uickl"))
                    myWalkTile(bankTile, 2);
            if(r == 1)
                if(!atNPC(getNearestNPCByID(bankerID), "ank Ba"))
                    myWalkTile(bankTile, 2);
            wait(random(200, 300));
            waitUntilNotMoving();
            return random(100, 300);
        }
        if(RSInterface.getInterface(INTERFACE_BANK).isValid()) {
            coalBanked += getInventoryCount(coalID);
            mithBanked += getInventoryCount(mithrilID);
            gemsBanked += getInventoryCount(gemID);
            bank.depositAll();

            moveMouse(52 + random(-10, 10), 106 + random(-10, 10));
            if(getMenuItems().get(0).toLowerCase().contains(("pickaxe").toLowerCase()) && !getMenuItems().get(0).toLowerCase().contains(("Broken").toLowerCase())) {
                clickMouse(true);
                wait(random(1100, 1500));
            } else {
                log("No useable pickaxe, ending script =(");
                bank.close();
                printProgressReport();
                stopAllScripts();
            }
            bank.close();
        }
        return 99999;
    }

    int headAttempts;
    public int fixPickaxe() {
        RSItemTile head = getGroundItemByID(17, pickaxeHeadID);
        if(head != null) {
            log("Getting pickaxe head...");
            myWalkTile(head, 1);
            waitUntilNearTile(head, 0);
            headAttempts = 0;
            while(!atTile(head, "Take") || headAttempts <= 10) {
                setCameraRotation(random(1, 359));
                if(random(0, 3) == 0)
                    atTile(randomizeTile(head, 1, 1), "Walk");
                headAttempts++;
                
            }
        }
        //if(equipmentContains(pickaxeHandleID) || equipmentContains(brokenPickaxeID))
            unequipWeapon();
        openTab(TAB_INVENTORY);
        wait(random(200, 300));
        if(getInventoryItemByID(pickaxeHeadID) != null && getInventoryItemByID(pickaxeHandleID) != null)
            useItem(getInventoryItemByID(pickaxeHeadID), getInventoryItemByID(pickaxeHandleID));

        if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 40 && inventoryContainsOneOf(pickaxeID[5]))
            atInventoryItem(pickaxeID[5], "ield");
        else if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 30 && inventoryContainsOneOf(pickaxeID[4]))
            atInventoryItem(pickaxeID[4], "ield");
        else if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 20 && inventoryContainsOneOf(pickaxeID[3]))
            atInventoryItem(pickaxeID[3], "ield");
        else if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 5 && inventoryContainsOneOf(pickaxeID[2]))
            atInventoryItem(pickaxeID[2], "ield");
        else if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 1 && inventoryContainsOneOf(pickaxeID[1]))
            atInventoryItem(pickaxeID[1], "ield");
        else if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 1 && inventoryContainsOneOf(pickaxeID[0]))
            atInventoryItem(pickaxeID[0], "ield");
        return random(200, 400);
    }

    public boolean canEquipPickaxe() {
        if((skills.getCurrentSkillLevel(STAT_ATTACK) >= 40 && inventoryContainsOneOf(pickaxeID[5])) ||
           (skills.getCurrentSkillLevel(STAT_ATTACK) >= 30 && inventoryContainsOneOf(pickaxeID[4])) ||
           (skills.getCurrentSkillLevel(STAT_ATTACK) >= 20 && inventoryContainsOneOf(pickaxeID[3])) ||
           (skills.getCurrentSkillLevel(STAT_ATTACK) >= 5 && inventoryContainsOneOf(pickaxeID[2])) ||
           (skills.getCurrentSkillLevel(STAT_ATTACK) >= 1 && inventoryContainsOneOf(pickaxeID[1])) ||
           (skills.getCurrentSkillLevel(STAT_ATTACK) >= 1 && inventoryContainsOneOf(pickaxeID[0])))
            return true;
        return false;
    }
    
    public int wieldPickaxe() {
        if(RSInterface.getInterface(INTERFACE_BANK).isValid())
            bank.close();

        if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 40 && inventoryContainsOneOf(pickaxeID[5]))
            atInventoryItem(pickaxeID[5], "ield");
        else if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 30 && inventoryContainsOneOf(pickaxeID[4]))
            atInventoryItem(pickaxeID[4], "ield");
        else if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 20 && inventoryContainsOneOf(pickaxeID[3]))
            atInventoryItem(pickaxeID[3], "ield");
        else if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 5 && inventoryContainsOneOf(pickaxeID[2]))
            atInventoryItem(pickaxeID[2], "ield");
        else if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 1 && inventoryContainsOneOf(pickaxeID[1]))
            atInventoryItem(pickaxeID[1], "ield");
        else if(skills.getCurrentSkillLevel(STAT_ATTACK) >= 1 && inventoryContainsOneOf(pickaxeID[0]))
            atInventoryItem(pickaxeID[0], "ield");
        return random(200, 400);
    }

    public int depositInventory() {
        if(getMyPlayer().getLocation().getY() > 6000) {
            if(myWalkPath(coalToLadderPath, 15, 3)) {
                waitUntilNotMoving();
                climbUpLadder();
            }
            return random(100, 200);
        }
        if(distanceTo(bankTile) > 4) {
            if(myWalkTile(bankTile, 1)) {
                wait(random(50, 600));
                if(random(0, 4) < 3)
                    moveMouse(random(100, 415), random(100, 237));
                waitUntilNotMoving();
            } else {
                RSTile theTile = betweenBankAndLadderTiles[random(0, betweenBankAndLadderTiles.length)];
                myWalkTile(theTile, 1);
                if(random(0, 2) == 0)
                    setCameraAltitude(true);
                waitUntilNearTile(theTile, 2);
            }
            return random(200, 300);
        }
        if(!RSInterface.getInterface(INTERFACE_BANK).isValid()) {
            int r = random(0, 2);
            if(r == 0)
                if(!atObject(getNearestObjectById(15, bankBoothID), "uickl"))
                    myWalkTile(bankTile, 2);
            if(r == 1)
                if(!atNPC(getNearestNPCByID(bankerID), "ank Ba"))
                    myWalkTile(bankTile, 2);
            wait(random(200, 300));
            waitUntilNotMoving();
            return random(200, 300);
        }
        if(RSInterface.getInterface(INTERFACE_BANK).isValid()) {
            coalBanked += getInventoryCount(coalID);
            mithBanked += getInventoryCount(mithrilID);
            gemsBanked += getInventoryCount(gemID);
            bank.depositAllExcept(pickaxeID);
            if(random(0, 5) == 0)
                bank.close();
        }
        return random(25, 100);
    }

    public void mouseOverMiningSkill() {
        openTab(TAB_STATS);
        //2 interfaces, one for the pickaxe image, other for the skill text
        RSInterfaceChild one = RSInterface.getInterface(320).getChild(9);
        RSInterfaceChild two = RSInterface.getInterface(320).getChild(10);
        if(random(0, 2) == 0)
            moveMouse(new Point(one.getAbsoluteX() + random(2, one.getWidth() - 1), one.getAbsoluteY() + random(2, one.getHeight() - 1)));
        else
            moveMouse(new Point(two.getAbsoluteX() + random(2, two.getWidth() - 1), two.getAbsoluteY() + random(2, two.getHeight() - 1)));
    }

    //4% chance of doing antiban: 17/425, every 4.8-19.2 seconds doing antiban
    public int antiBan() {
        switch(random(0, 425)) {
            case 0: setCameraRotation(random(1, 359)); break;
            case 1: setCameraRotation(random(1, 359)); break;
            case 2: setCameraRotation(random(1, 359)); break;
            case 3: setCameraRotation(random(1, 359)); break;
            case 4: setCameraRotation(random(1, 359)); break;
            case 5: setCameraRotation(random(1, 359)); break;

            case 6: setRun(true); break;

            case 7: moveMouse(random(0, 515), random(0, 337)); break;
            case 8: moveMouse(random(0, 515), random(0, 337)); break;
            case 9: moveMouse(random(100, 415), random(100, 237)); break;
            case 10: moveMouse(random(100, 415), random(100, 237)); break;
            case 11: moveMouse(random(100, 415), random(100, 237)); break;
            case 12: moveMouse(random(0, 764), random(0, 502)); break;

            case 13: mouseOverMiningSkill(); break;
            case 14: mouseOverMiningSkill(); break;

            case 15: openTab(TAB_INVENTORY); break;
            case 16: openTab(random(0, 13)); break;

            default: break;
        }
        return random(50, 200);
    }

    RSTile lastRockLocation = new RSTile(0000, 0000);
    RSObject rock;
    long timeIdle = System.currentTimeMillis();

    public boolean mineNewRock() {
        RSObject obj = getObjectAt(lastRockLocation);
        if(obj == null)
            return true;
        for(int i = 0; i < coalRockID.length; i++) {
            if(obj.getID() == coalRockID[i])
                return false;
        }
        for(int i = 0; i < mithRockID.length; i++) {
            if(obj.getID() == mithRockID[i])
                return false;
        }
        return true;
    }

    public boolean atRock(RSObject obj) {
        try {
            Point location = Calculations.tileToScreen(obj.getLocation());
            if (location.x == -1 || location.y == -1) return false;
            moveMouse(location, 3, 3);
            wait(random(40, 80));
            boolean validRock = false;
            RSObject temp = getObjectAt(obj.getLocation());
            if(temp != null) {
                int id = temp.getID();
                for(int i = 0; i < coalRockID.length; i++) {
                    if(id == coalRockID[i])
                        validRock = true;
                }
                if(!validRock) {
                    for(int i = 0; i < mithRockID.length; i++) {
                        if(id == mithRockID[i])
                            validRock = true;
                    }
                }
            }
            if(!validRock)
                return false;
            if(!getMenuItems().get(0).toLowerCase().contains(("ine R").toLowerCase())) {
                moveMouse(location, 6, 6);
                wait(random(40, 80));
                if(!getMenuItems().get(0).toLowerCase().contains(("ine R").toLowerCase())) {
                    moveMouse(location, 6, 6);
                    wait(random(40, 80));
                    if(!getMenuItems().get(0).toLowerCase().contains(("ine R").toLowerCase())) {
                        moveMouse(location, 6, 6);
                        wait(random(40, 80));
                    }
                }
            }
                
            if(getMenuItems().get(0).toLowerCase().contains(("ine R").toLowerCase())) {
                clickMouse(true);
            } else {
                clickMouse(false);
                if(!atMenu("ine R"))
                    return false;
            }
            wait(random(500, 1000));
            waitUntilNotMoving();
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    private boolean isObjectOccupied(RSObject obj) {
        Player[] players = Bot.getClient().getPlayerArray();
        int[] playerIndex = Bot.getClient().getPlayerIndexArray();
        if(obj.getLocation() == null)
            return true;
        for(int element : playerIndex) {
            if(players[element] == null)
                continue;
            RSPlayer player = new RSPlayer(players[element]);
            if(!player.getName().equals(getMyPlayer().getName()))
                if(distanceBetween(obj.getLocation(), player.getLocation()) < 2 && player.getAnimation() != -1)
                    return true;
        }
        return false;
    }

    private RSObject findNearestUnoccupiedObject(RSObject... objects) {
        RSObject nearestObj = null;
        for(int i = 0; i < objects.length; i++) {
            if(isObjectOccupied(objects[i]))
                continue;
            if(nearestObj == null)
                nearestObj = objects[i];
            else if(distanceTo(objects[i].getLocation()) < distanceTo(nearestObj.getLocation()))
                nearestObj = objects[i];
        }
        return nearestObj;
    }

    public int mineCoal() {
        if(getMyPlayer().getLocation().getY() < 6000) {
            if(!climbDownLadder()) {
                if(Calculations.onScreen(Calculations.tileToScreen(topLadderObjectTile)))
                    return random(20, 80);
                if(myWalkTile(ladderTile, 2)) {
                    if(random(0, 4) < 3)
                        moveMouse(random(100, 415), random(100, 237));
                    waitUntilNearTile(ladderTile, 0);
                } else {
                    RSTile theTile = betweenBankAndLadderTiles[random(0, betweenBankAndLadderTiles.length)];
                    myWalkTile(theTile, 1);
                    if(random(0, 2) == 0)
                        setCameraAltitude(true);
                    waitUntilNearTile(theTile, 2);
                }
                return random(200, 300);
            }
            return random(200, 400);
        }

        if(getMyPlayer().getAnimation() != -1)
            timeIdle = System.currentTimeMillis();
        
        if(getObjectAt(lastRockLocation) == null)
            lastRockLocation = new RSTile(0000, 0000);

        if(mineNewRock() || ((getMyPlayer().getAnimation() == -1) && (System.currentTimeMillis() - timeIdle >= 4000) && !getMyPlayer().isMoving())) {
            rock = null;
            if(miningMith && (findNearestUnoccupiedObject(findObjects(16, mithRockID)) != null || getNearestObjectById(16, mithRockID) != null)) {
                if(findNearestUnoccupiedObject(findObjects(16, mithRockID)) != null)
                    rock = findNearestUnoccupiedObject(findObjects(16, mithRockID));
                else
                    rock = getNearestObjectById(16, mithRockID);
            } else {
                if(findNearestUnoccupiedObject(findObjects(10, coalRockID)) != null)
                    rock = findNearestUnoccupiedObject(findObjects(10, coalRockID));
                else
                    rock = getNearestObjectById(16, coalRockID);
            }
            if(rock == null) {
                if(distanceTo(ladderToCoalPath[ladderToCoalPath.length - 1]) < 6) {
                    myWalkPath(coalToLadderPath, 15, 3);
                    wait(random(50, 600));
                    if(random(0, 4) < 3)
                        moveMouse(random(100, 415), random(100, 237));
                    waitUntilNotMoving();
                    return random(50, 200);
                }
                if(distanceTo(coalToLadderPath[coalToLadderPath.length - 1]) < 6) {
                    myWalkPath(ladderToCoalPath, 15, 3);
                    wait(random(50, 600));
                    if(random(0, 4) < 3)
                        moveMouse(random(100, 415), random(100, 237));
                    waitUntilNotMoving();
                    return random(50, 200);
                }
                if(random(0, 2) == 0)
                    myWalkPath(ladderToCoalPath, 17, 3);
                else
                    myWalkPath(coalToLadderPath, 17, 3);

                wait(random(50, 600));
                if(random(0, 4) < 3)
                    moveMouse(random(100, 415), random(100, 237));
                waitUntilNotMoving();
                return random(50, 200);
            }
            if(rock.getLocation().getY() > 9756) {
                myWalkPath(coalToLadderPath, 17, 3);
                waitUntilNotMoving();
                lastRockLocation = new RSTile(0000, 0000);
                return random(50, 200);
            }
            //if(!tileOnScreen(rock.getLocation())) {
            if(!Calculations.onScreen(Calculations.tileToScreen(rock.getLocation()))) {
                if(!myWalkTile(rock.getLocation(), 2)) {
                    lastRockLocation = new RSTile(0000, 0000);
                    return random(20, 40);
                }
                if(random(0, 4) == 0)
                    setCameraAltitude(true);
                wait(random(50, 200));
                if(random(0, 4) < 3)
                    moveMouse(random(100, 415), random(100, 237));
                waitUntilNotMoving();
                return random(50, 200);
            }
            lastRockLocation = rock.getLocation();
            if(!atRock(rock))
                setCameraRotation(random(1, 359));

            return random(100, 300);
        }
        return antiBan();
    }

    int tries = 0;
    public int teleportToLumbridge() {
        if(distanceTo(lumbridgeTile) > 17) {
            castSpell(1);
            wait(random(1500, 2400));
            if(getMyPlayer().getAnimation() != -1) {
                wait(random(12500,14000));
            } else {
                tries++;
                if(tries >= 4) {
                    log("Unable to teleport to lumbridge, stopping script");
                    printProgressReport();
                    stopAllScripts();
                }
                int r = random(120000, 400000);
                log("Unable to teleport to lumbridge, will attempt again in " + (r / 1000) + "seconds");
                printProgressReport();
                logout();
                wait(r);
                login();
            }
        }
        myWalkTile(lumbridgeTile, 1);
        setRun(true);
        waitUntilNearTile(lumbridgeTile, 2);
        return random(100, 600);
    }

    public void waitUntilNotMoving() {
        wait(random(700, 1000));
        while(getMyPlayer().isMoving())
            wait(random(25, 100));
    }

    public void waitUntilNearTile(RSTile tile, int dist) {
        wait(random(700, 1000));
        while(distanceTo(tile) >= dist && getMyPlayer().isMoving())
            wait(random(25, 100));
    }

    public boolean myWalkTile(RSTile theTile, int randomness) {
        if(theTile == null)
            return false;
        if((distanceTo(theTile)) <= 17) {
            RSTile newTile;
            if(randomness == 0)
                newTile = new RSTile(theTile.getX(), theTile.getY());
            else
                newTile = new RSTile(theTile.getX() + random(-randomness, randomness + 1), theTile.getY() + random(-randomness, randomness + 1));

            if(random(0, 30) == 0)
                turnToTile(newTile, 15);

            if(tileOnScreen(newTile) && random(0, 10) == 0) {
                if(!atTile(newTile, "Walk")) {
                    if(!walkTileMM(newTile)) {
                        //log("Failed walking to tile: (" + theTile.getX() + ", " + theTile.getY() + ")");
                        return false;
                    } else {
                        return true;
                    }
                } else {
                    return true;
                }
            } else {
                if(!walkTileMM(newTile)) {
                    //log("Failed walking to tile: (" + theTile.getX() + ", " + theTile.getY() + ")");
                    return false;
                } else {
                    return true;
                }
            }
        } else {
            //log("Tile out of reach: (" + theTile.getX() + ", " + theTile.getY() + ")");
            return false;
        }
    }

    public RSTile myGetNextTile(RSTile[] path, int maxDist) {
        for(int i = path.length - 1; i >= 0; i--) {
            if(distanceTo(path[i]) <= maxDist) {
                return path[i];
            }
        }
        return null;
    }

    /**
     * Walks to the next reachable tile in the path
     *
     * @param path The path it will walk
     * @param maxDist The max distance it will search for the next tile in the path
     * @param randomness the randomness it will add to clicking the tile
     * @return if you are within 4 tiles of the destination
     */
    public boolean myWalkPath(RSTile[] path, int maxDist, int randomness) {
        if(distanceTo(path[path.length - 1]) <= 4) {
            return true;
        } else {
            RSTile theTile = myGetNextTile(path, maxDist);
            if(theTile != null) {
                myWalkTile(theTile, randomness);
                waitUntilNearTile(theTile, 2);
            }
            return false;
        }
    }

    public RSObject getNearestObjectById(int range, int... ids) {
        for(int i = 0; i <= range; i++) {
            RSObject temp = findObject(i, ids);
            if(temp != null) {
                return temp;
            }
        }
        return null;
    }

    public RSObject[] findObjects(int range, int... ids) {
        ArrayList<RSObject> matches = new ArrayList<RSObject>();
        RSTile pos = getMyPlayer().getLocation();
        int xBegin = pos.getX() - range;
        int yBegin = pos.getY() - range;
        int xEnd = pos.getX() + range;
        int yEnd = pos.getY() + range;
        for (int x = xBegin; x < xEnd; x++) {
            for (int y = yBegin; y < yEnd; y++) {
                RSTile t = new RSTile(x, y);
                RSObject obj = getObjectAt(t);
                if (obj == null)
                    continue;
                for (int objType : ids) {
                    if (objType == obj.getID())
                        matches.add(obj);
                }
            }
        }
        try {
            matches.trimToSize();
            return (RSObject[]) matches.toArray(new RSObject[matches.size()]);
        } catch (Exception e) { }
        return new RSObject[0];
    }

}

 

Yea, it is. love uploaded it