Tenacs Guild Miner?

Can someone send me a link to download Tenacs Guild miner as the one on the Sticky collection of RSbot scripts dosen't work.

Thanks

 

If you can get the java i can get you the .class

just go to rsbot.org and look under mining scripts.

 

Here is a link http://sharecash.org/download.php?id=202, dont know if it works anymore though.

 

I cant get on to rsbot.org

 

I need the 2.1 version badly aswell, that link posted above is crap lol, u need to complete an offer or something and than it doesn't even redirects you to the download page :/

 

here is the script
your welcome
this site sucks dick
i hope i get banned
but ill help you by doing it

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) <= 17)
return false;
for(int i = 0; i < coalToLadderPath.length - 1; i++)
if(distanceTo(coalToLadderPath) <= 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, "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)) {
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)) {
if(atInventoryItem(junkItems, "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)
return false;
}
for(int i = 0; i < mithRockID.length; i++) {
if(obj.getID() == mithRockID)
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)
validRock = true;
}
if(!validRock) {
for(int i = 0; i < mithRockID.length; i++) {
if(id == mithRockID)
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))
continue;
if(nearestObj == null)
nearestObj = objects;
else if(distanceTo(objects.getLocation()) < distanceTo(nearestObj.getLocation()))
nearestObj = objects;
}
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) <= maxDist) {
return path;
}
}
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];
}

}