.:[~]Official RSBot Scripts+Requests Sticky!{RSBot}[~]:.

[imaussie]

Umm well im trying to use the monkfish frenzy bot, but im unsure as to what program i run it through as it wont work, any suggestions?

 

[Party_dude]

Script name: MonkeyAgilityCourse.java
Script author:unknown
It does the ape atoll agility course (supposed to be more xp than the wilderness one).
*note: i havent tested this one cause i don't have the agility lvl

import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.math.BigDecimal;

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

public class MonkeyAgilityCourse extends Script implements ServerMessageListener, PaintListener {
public static final int[]         Food = new int[] { 333, 385, 379, 285, 373, 365, 7946, 361, 397, 391, 1963, 329 } ;
    int state = 0 ;
    long            startTime;
    Color WHITE = new Color(255, 255, 255, 100);
    Color GREEN = new Color(0, 50, 10, 255);
    Color RED = new Color(100, 0, 0, 255);

    boolean proggy=true;


    private int State = 0;
    private final RSTile[] ToRocks = {
        new RSTile (2770, 2747),
        new RSTile (2768, 2746),
        new RSTile (2772, 2735),
        new RSTile (2765, 2747),
        new RSTile (2763, 2748),
        new RSTile (2760, 2748),
        new RSTile (2765, 2760),
        new RSTile (2758, 2745),
        new RSTile (2755, 2742),
};
    private final RSTile[] ToRope = {
        new RSTile (2742, 2741),
        new RSTile (2743, 2738),
        new RSTile (2747, 2734),
        new RSTile (2770, 2747),
        new RSTile (2751, 2731),
};
private final RSTilePath ToRocksPath = new RSTilePath(ToRocks, this);
private final RSTilePath ToRopePath = new RSTilePath(ToRope, this);










    int step=1;    public boolean arePlayersWithin(int x1, int y1, int x2, int y2) {
        int Dist = 20;
        RSPlayer closest = null;
        int[] validPlayers = Bot.getClient().getPlayerIndexArray();
        Player[] players = Bot.getClient().getPlayerArray();

        for (int element : validPlayers) {
            if (players[element] == null) {
                continue;
            }
            RSPlayer player = new RSPlayer(players[element]);
            try {
                int x = player.getLocation().getX();
                int y = player.getLocation().getY();
                if(x>=x1 && y>=y1 && x<=x2 && y<=y2) {
                    return true;
                }
            } catch (Exception e) {}
        }
return false;
}
    public void serverMessageRecieved(ServerMessageEvent e) {
         String message = e.getMessage().toLowerCase();

         if(message.contains("...and slide back down the slope.")) {
            state = 3;
         }

         if(message.contains("...something in the water bites you.")) {
            state = 1;
}
         if(message.contains("Something in the water bites you...")) {
           state = 1;
}
         if(message.contains("Whoops! You lose your grip and fall into the river.")) {
            state = 0;
}
         if(message.contains("You slip andfall into the river.")) {
           state = 1;
}


     }

    public void onRepaint(Graphics g) { //stole transparent box from ~alex~'s AlFlax
        // local objects:
        int    index = skills.getStatIndex("Agility");
        int exp = 0;
        int levels;
        long hours = 0, minutes = 0, seconds = 0;
        long time;
        long untilhour = 0, untilmin = 0, untilsec = 0;
        double temptime = 0;

        // Has start time been previously set?
        if ( startTime == 0 ) {
            startTime = System.currentTimeMillis( );
        }

        // Calculate hours, minutes and seconds.
        time = System.currentTimeMillis( ) - startTime;
        seconds = (time / 1000);
        if ( seconds >= 60 ) {
            minutes = (seconds / 60);
            seconds -= (minutes * 60);
        }
        if ( minutes >= 60 ) {
            hours = (minutes / 60);
            minutes -= (hours * 60);
        }
        if (isLoggedIn() && proggy==true) {
            int x = 18;
            int y = 169;
            g.setColor(WHITE);
            g.fill3DRect(14, 169, 210, 145, true);
            g.setColor(GREEN);
            g.drawString(getName()+" v" + getVersion(),x, y += 20);
            g.drawString("By: "+getAuthor(), x, y += 20);
            g.setColor(RED);
            g.drawString("Course Completed " + count + " times.", x, y += 20);
            g.setColor(GREEN);
            g.drawString("Gained "+(skills.getCurrentSkillExp(STAT_AGILITY)-startingXp)+"xp", x, y += 20);
            g.drawString("Gained "+(skills.getCurrentSkillLevel(STAT_AGILITY)-startingLevel)+" levels", x, y += 20);
            g.drawString(skills.getPercentToNextLevel(STAT_AGILITY)+"% to next lvl", x, y += 20);
            g.drawString("Time running: " + hours + "." + minutes + "." + seconds, x, y += 20);
        }
    }
    int count;
    int startingXp;
    int startingLevel;
    RSObject temp;

    public String getName() {  
        return "Monkey Agility Course";   
    }

    public double getVersion() {   
        return 1.0;       
    }

    public String getAuthor() { 
        return "ViXoR & Lordlord";   
    }

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

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

    public boolean onStart(String[] args) {  

        proggy=true;
        count=0;
        startingXp=skills.getCurrentSkillExp(STAT_AGILITY);
        startingLevel=skills.getRealSkillLevel(STAT_AGILITY);
        step=1;
        Bot.getEventManager().addListener(ServerMessageListener.class, this);
Bot.getEventManager().addListener(PaintListener.class, this);
        return true;   
    }

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

    public boolean Eat() {
    for(int i = 0; i<Food.length; i++) {
        if(getInventoryCount(Food[i]) >= 1) {
            atInventoryItem(Food[i], "Eat");
            return true;
        }
    }
    return false;
    }

    public int loop() {
if(getMyPlayer().getAnimation() != -1) return random(1000, 2000);
if(skills.getCurrentSkillLevel(3) <= 15) {
        log("Health is below 15. Eating food...");
        if(!Eat()) {
            wait ( random(10000, 12000) );
            logout();
            Bot.getScriptHandler().stopScript(this.ID);
        } else
            return random(800, 1200);
}
RSTile stoneTile = new RSTile(2755, 2742);
if(canReach(stoneTile, false)) {
  if(distanceTo(stoneTile) <=1)
    state = 0;
  else
    walkTileMM(stoneTile);

}else
if(canReach(findObject(12570),false)){
state = 1;
}else
if(distanceTo(new RSTile(2747,2741)) <= 1) {
state = 3;
}else
if(distanceTo(new RSTile(2751,2731)) <= 1) {
state = 4;
}else
if(getMyPlayer().getLocation().equals(new RSTile(2752,2730))) {
walkTileMM(new RSTile(2751,2731));
}

try{
    switch(state){
    case 0:


   if (distanceTo(ToRocks[0]) < 6) ToRocksPath.walkToEnd();
                setCameraRotation(75);
                setCameraAltitude(true);
                wait(random(500,1500));
    RSObject Stepping_Stone = getObjectAt(new RSTile(2754, 2742));
    if(Stepping_Stone != null){
    //    log("ID "+Stepping_Stone.getID()+"   X:"+Stepping_Stone.getLocation().getX()+"   Y:"+Stepping_Stone.getLocation().getY());
 if(atTile(new RSTile(2754, 2742), "Jump-to")) {
            log("Found Stepping Stone!");
            state++;
       return random(2500, 3000);
}

    return random (500,1000);
}
            log("Couldn't Find Stone");

                ToRocksPath.walkToEnd();
                return random(500,1000);
    case 1:
                wait(random(2000,2500));
                RSObject TropTree = findObject (12570);
                if(TropTree != null){
                  if(atObject(TropTree, "Climb")) {
                        log("Tropical Tree Found!");
                    state++;
                    return random(2500, 3000);
             }
                  return random(500, 1000);
            }
            log("Couldn't Find Tropical Tree");
                  return random(500, 1000);
    case 2:
                wait(random(2000,2500));
                setCameraRotation(240);
                setCameraAltitude(true);
                RSObject Monkeybars = findObject (12573);
                if(Monkeybars != null){
                  if(atObject(Monkeybars, "Swing Across")) {
                        log("Monkeybars Found!");
                    state++;
                    return random(2500, 3000);
             }
                  return random(500, 1000);
            }
            log("Couldn't Find Monkeybars");
                  return random(500, 1000);
    case 3:
                setCameraRotation(260);
            input.pressKey((char) KeyEvent.VK_DOWN);
wait(random(1000,1500));
input.releaseKey((char) KeyEvent.VK_DOWN);
                wait(random(2000,2500));
                RSObject Slope = findObject (12576);
                if(Slope != null){
                  if(atObject(Slope, "Climb-up")) {
                        log("Skull Slope Found!");
                    state++;
                    return random(2500, 3000);
             }
                  return random(500, 1000);
            }
            log("Couldn't Find Skull Slope");
                  return random(500, 1000);
    case 4:
                wait(random(2000,2500));
                setCameraRotation(173);
            input.pressKey((char) KeyEvent.VK_UP);
wait(random(1000,1500));
input.releaseKey((char) KeyEvent.VK_UP);
       if (distanceTo(ToRope[0]) <= 1) ToRopePath.walkToEnd();
Point Rope = Calculations.tileToScreen(new RSTile(2752, 2730), 40);
    moveMouse(Rope,3,3);
    if(getMenuItems().get(0).toLowerCase().contains("swing")) {
    clickMouse(true);
                      log("Rope Found!");
                    state++;
                    return random(2500, 3000);
             }
                  return random(500, 1000);
    case 5:
                RSObject TropTree1 = findObject (12618);
                if(TropTree1 != null){
                  if(atObject(TropTree1, "Climb-down")) {
                        log("Tropical Tree Found!");
                    state = 0;
                    return random(2500, 3000);
             }
                  return random(500, 1000);
            }
            log("Couldn't Find Tropical Tree");
                  return random(500, 1000);

    }
        }
    catch(Exception oo) {
     oo.printStackTrace();
    }

    return random(500,1000);
    }


    public String getScriptDescription() {
        return "<html>\n" +
            "<head></head>\n" +
            "<body>\n" +
            "<center>" +
            "<h2>" + getName() + "</h2>" +
            "</center>\n" +
            "<p>\n" +
            "<b>Author:</b> " + getAuthor() + "<p>\n" +
            "<b>Version:</b> " + getVersion() + "<p>\n" +
            "Start this script at the spot where you finish the lap." +
            "</body>\n" +
            "</html>";
    }








}

nice!!!!

 

[Party_dude]

need Crafting Guild Gold Miner and banker please


Thanks Party_Dude

 

[imaussie]

Umm well im trying to use the monkfish frenzy bot, but im unsure as to what program i run it through as it wont work, any suggestions?

 

[Captain Quasi]

Yeah ive gotten those scripts and i tried to open them and it just says corrupt. can anyone tell me how to correctly use these scripts?

 

[Jawarrior]

Name: BG tomato buyer
Function: The same as cheese buyer but tomato...

 

[Rapidfire]

It would be nice to have a script to deal with more randoms such as surprise exam and frogland.

 

[Caution]

Awsome All working, great anti-ban on RSbot aswell. Perfectly safe, great ;p

 

[gridfun]

I would put this under quests allso. - SuperRuneQuest - Rune mystery

import com.speljohan.rsbot.bot.Bot;
import com.speljohan.rsbot.script.Script;
import com.speljohan.rsbot.script.wrappers.*;
import com.speljohan.rsbot.script.*;
import com.speljohan.rsbot.script.Calculations;
import java.awt.*;


public class SuperRuneQuest extends Script {
	
	RSTile[] LUMMY_WIZZARD = new RSTile[] {
	new RSTile(3224, 3218),
	new RSTile(3232, 3219),
	new RSTile(3230, 3233),
	new RSTile(3218, 3245),
	new RSTile(3204, 3247),
	new RSTile(3193, 3236),
	new RSTile(3180, 3229),
	new RSTile(3165, 3225),
	new RSTile(3150, 3222),
	new RSTile(3141, 3212),
	new RSTile(3126, 3206),
	new RSTile(3114, 3207),
	new RSTile(3114, 3192),
	new RSTile(3114, 3178),
	new RSTile(3109, 3168),
	new RSTile(3109, 3168)};
	
	private RSTilePath toWizzard = new RSTilePath(LUMMY_WIZZARD, this);
	
	RSTile[] LUMMY_AUBURY = new RSTile[] {
	new RSTile(3222, 3220), new RSTile(3225, 3219), new RSTile(3239, 3225),
	new RSTile(3254, 3226), new RSTile(3259, 3241), new RSTile(3252, 3256),
 	new RSTile(3247, 3270), new RSTile(3240, 3282), new RSTile(3239, 3297),
	new RSTile(3245, 3312), new RSTile(3257, 3322), new RSTile(3269, 3330),
	new RSTile(3275, 3340), new RSTile(3282, 3349), new RSTile(3295, 3356),
	new RSTile(3295, 3371), new RSTile(3294, 3383), new RSTile(3293, 3398),
	new RSTile(3286, 3412), new RSTile(3277, 3424), new RSTile(3266, 3418),
 	new RSTile(3259, 3403), new RSTile(3253, 3401) };
 	
 	private RSTilePath toAubury = new RSTilePath(LUMMY_AUBURY, this);
	
	public int NOTES = 291;
	public int RESEARCH_PACKAGE = 290;
	public int AUBURY = 553;
	public int WIZZARD_ID = 300;
	public int DUKE = 741;
	public RSTile LUMMY_TILE = new RSTile(3218, 3218);
	public RSTile DOOR_TILE = new RSTile(3207, 3222);
	public RSTile WIZZ_DOOR_TILE = new RSTile(3109, 3166);
	public RSTile WIZZ_LADDER_TILE = new RSTile(3104, 3162);
	public RSTile DOWN_WIZZ_LADDER_TILE = new RSTile(3104, 9576);
	public RSTile WIZZ_LARGE_DOOR_TILE = new RSTile(3109, 9570);
	public int OPEN_DOOR_ID = 36845; //"Open"
	public int CLOSED_DOOR_ID = 36844; //"Close"
	public int WIZZ_DOOR_OPEN = 11994;
	public int WIZZ_DOOR_CLOSED = 11993;
	public int WIZZ_LARGE_DOOR_CLOSED = 33060;
	public RSTile UPSTAIRS_TILE = new RSTile(3205, 3229);
	public RSTile DOWNSTAIRS_TILE = new RSTile(3206, 3228);
	public int STAIRS_ID = 36777;
	public int AIR_TALLY = 1438;
	
	public boolean downStairs;
	public boolean downLadder;
/*
 *	Duke Interface = 228 - Child = 2 - Text = you any quests/no problem
 *	
 *
 *
 */

	public double getVersion( ) {
		return( 1.1 );
	}

	public String getName( ) {
		return( "Super Quest (Rune Mysteries)" );
	}

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

	public String getScriptCategory() {
		return( "Dave/Super Series" );
	}
	
	public boolean onStart(String[] args) {
		
		downStairs = false;
		downLadder = false;
		
		return true;
	}
	
	public int loop() {
		if(canContinue()) {
			clickContinue();
			wait(random(1000,2000));
		}
		if(getMyPlayer().isMoving()) return random(1000,2000);
		
		int state = runAway();
		if(state != 0)
			return state;
			
		state = toWizzards();
		if(state != 0)
			return state;
		
		return toAubury();
	}
	
	private int runAway() {	// Credits Linux_Communist	
		
	if(getMyPlayer().isInCombat() && !getMyPlayer().isMoving()) {
		wait(random(1000,2000));
		log("Running away");	
		RSTile foo, bar;
		foo = getMyPlayer().getLocation();
		setRun(true);
				
		bar = new RSTile(foo.getX()+random(8,10),foo.getY()+random(8,10));
				
		walkTileMM(bar);
		wait(random(17000,20000));
		walkTileMM(foo);
	}
		return 0;
	}
	
	public int toWizzards() {
		
		RSNPC wizz = getNearestNPCByID(WIZZARD_ID);
		RSNPC duke = getNearestNPCByID(DUKE);
		RSObject lumbDoor = findObject(CLOSED_DOOR_ID);
		RSObject wizzDoor = findObject(WIZZ_DOOR_CLOSED);
		RSObject wizzLargeDoor = findObject(WIZZ_LARGE_DOOR_CLOSED);
		RSObject stairs = findObject(STAIRS_ID);
		
		if(duke != null && !inventoryContains(AIR_TALLY) && !RSInterface.getInterface(228).isValid() 
			&& !RSInterface.getInterface(228).isValid()
			&& !RSInterface.getInterface(210).isValid()
			&& !RSInterface.getInterface(242).isValid() 
			&& !RSInterface.getInterface(243).isValid() 
			&& !RSInterface.getInterface(230).isValid()
			&& !RSInterface.getInterface(64).isValid()) {
			log("Finding Duke");
			atNPC(duke, "Talk");
			wait(random(1000,2000));
		} else 
			if(RSInterface.getInterface(228).getChild(2).getText().contains("you any quests") 
				|| RSInterface.getInterface(228).getChild(2).getText().contains("no problem")) {
				atInterface(228, 2, "Continue");
					wait(random(300,600));
			} else 
				if(inventoryContains(AIR_TALLY) && distanceTo(DOOR_TILE) < 6) {
					if(!canReach(findObject(36817), true)) {
						log("Opening Door");
					atTile(DOOR_TILE, "Open");
					} else 
							log("Walking to Stairs");
						walkTileMM(UPSTAIRS_TILE);
							return random(1000,2000);
					} else 
						if(inventoryContains(AIR_TALLY) && distanceTo(UPSTAIRS_TILE) < 6 && !RSInterface.getInterface(230).isValid() && !downStairs) {
						log("Climbing down-stairs");
						atTile(UPSTAIRS_TILE, "Climb");
							return random(2000,3000);
					} else 
						if(RSInterface.getInterface(230).getChild(3).getText().contains("Go down")) {
							atInterface(230, 3, "Continue");
							downStairs = true;
							wait(random(2000,3000)); 
					} else
						if(downStairs && inventoryContains(AIR_TALLY) && distanceTo(LUMMY_TILE) > 5 && !downLadder && distanceTo(WIZZ_LADDER_TILE) > 20) {
							log("Walking into lummy");
							walkTileMM(LUMMY_TILE);
							return random(1000,2000);
						} else 
							if(distanceTo(LUMMY_TILE) < 5 && inventoryContains(AIR_TALLY) || distanceTo(LUMMY_TILE) < 5 && inventoryContains(NOTES)) {
								RSTile tile2 = new RSTile(3228, 3218);
								walkTileMM(tile2);
								wait(random(1000,2000));
							try {
								log("Walking to wizzard tower");
								toWizzard.walkToEnd();
							} catch (InterruptedException e) {
								}
						} else 
							if(distanceTo(WIZZ_DOOR_TILE) < 5 && inventoryContains(AIR_TALLY) && wizzDoor != null
								|| distanceTo(WIZZ_DOOR_TILE) < 5 && inventoryContains(NOTES) && wizzDoor != null) {
								log("Opening door");
								atObject(wizzDoor, "Open");
									wait(random(1000,2000));
									log("Walking to ladder");
									walkTileMM(WIZZ_LADDER_TILE);
									return random(1000,2000);
							} else 
								if(distanceTo(WIZZ_LADDER_TILE) < 3 && inventoryContains(AIR_TALLY) || distanceTo(WIZZ_LADDER_TILE) < 3 && inventoryContains(NOTES)) {
									log("Climbing down ladder");
									atTile(WIZZ_LADDER_TILE, "Climb-down");
									downLadder = true;
									return random(1000,2000);
						} else 
							if(distanceTo(DOWN_WIZZ_LADDER_TILE) < 2 && inventoryContains(AIR_TALLY) || distanceTo(DOWN_WIZZ_LADDER_TILE) < 2 && inventoryContains(NOTES)) {
								log("Walking to door");
								walkTileMM(WIZZ_LARGE_DOOR_TILE);
								return random(1000,2000);
					} else 
							if(distanceTo(WIZZ_LARGE_DOOR_TILE) < 5 && inventoryContains(AIR_TALLY) || distanceTo(WIZZ_LARGE_DOOR_TILE) < 5 && inventoryContains(NOTES)) {
								setCompass('w');
								if(!canReach(wizz, false) && wizzLargeDoor != null) {
									log("Opening large door");
									atObject(wizzLargeDoor, "Open");
									wait(random(1000,2000));
								} else {
									log("Walking into wizzard room");
									RSTile tile1 = new RSTile(3102, 9570);
									walkTileMM(tile1);
									return random(1000,2000);
								}
				} else 
					if(wizz != null && !RSInterface.getInterface(228).isValid() && inventoryContains(AIR_TALLY)
						&& !RSInterface.getInterface(242).isValid() 
						&& !RSInterface.getInterface(64).isValid()
						&& !RSInterface.getInterface(66).isValid()
						&& !RSInterface.getInterface(241).isValid()
						&& !RSInterface.getInterface(243).isValid()
						&& !RSInterface.getInterface(210).isValid()
						&& !RSInterface.getInterface(230).isValid()
						&& !RSInterface.getInterface(277).isValid()
						&& !RSInterface.getInterface(244).isValid()) {
						log("Finding wizzard");
						atNPC(wizz, "Talk-to");
							return random(1000,2000);
				} else
					if(inventoryContains(NOTES) && wizz != null 
					&& !RSInterface.getInterface(228).isValid()
					&& !RSInterface.getInterface(242).isValid() 
					&& !RSInterface.getInterface(64).isValid()
					&& !RSInterface.getInterface(66).isValid()
					&& !RSInterface.getInterface(241).isValid()
					&& !RSInterface.getInterface(243).isValid()
					&& !RSInterface.getInterface(210).isValid()
					&& !RSInterface.getInterface(65).isValid()
					&& !RSInterface.getInterface(211).isValid()
					&& !RSInterface.getInterface(277).isValid()
					&& !RSInterface.getInterface(230).isValid()
					&& !RSInterface.getInterface(244).isValid()) {
						log("Finding wizzard");
						atNPC(wizz, "Talk-to");
							return random(1000,2000);
			} else 
				if(RSInterface.getInterface(230).getChild(4).getText().contains("looking for the head")) {
					clickMouse(280 + random(-2, 2), 440 + random(-2, 2), true);
					//atInterface(230, 4, "Continue");
						return random(1000,2000);
				} else 
					if(RSInterface.getInterface(228).getChild(2).getText().contains("here you are")) {
						atInterface(228, 2, "Continue");
						return random(1000,2000);
					} else
						if(RSInterface.getInterface(228).getChild(2).getText().contains("certainly")) {
							atInterface(228, 2, "Continue");
							return random(1000,2000);
					} else 
						if(RSInterface.getInterface(277).getChild(4).getText().contains("the Rune")) {
							log("Completed Rune Mysteries Quest - Shutting down");
							atInterface(277, 18, "Close");
							stopAllScripts();
						}									
		return 0;	
	}
	
	public int toAubury() {
		
		RSNPC Aubury = getNearestNPCByID(AUBURY);
		RSTile tile3 = new RSTile(3253, 3402);
				
		if(distanceTo(LUMMY_TILE) > 10 && inventoryContains(RESEARCH_PACKAGE) && distanceTo(Aubury) > 25) {
			if(getCurrentTab() != TAB_MAGIC) openTab(TAB_MAGIC);
			log("Teleporting home");
			if(getMyPlayer().getAnimation() == -1) {
				castSpell(1);
				wait(random(13000,14000));
				downLadder = false;
			}		
		} else 
			if(distanceTo(LUMMY_TILE) < 6 && inventoryContains(RESEARCH_PACKAGE)) {
				try {
					log("Walking to Aubury");
					toAubury.walkToEnd();
				} catch (InterruptedException i) {
				}
			} else
				if(Aubury != null && inventoryContains(RESEARCH_PACKAGE) && !RSInterface.getInterface(241).isValid()
					&& !RSInterface.getInterface(243).isValid()
				 	&& !RSInterface.getInterface(230).isValid()
				 	&& !RSInterface.getInterface(65).isValid()
				 	&& !RSInterface.getInterface(210).isValid()
				 	&& !RSInterface.getInterface(242).isValid()
				 	&& !RSInterface.getInterface(230).isValid()
				 	&& !RSInterface.getInterface(244).isValid()) {
					log("Talking to Aubury");
					atNPC(Aubury, "Talk-to");
					return random(1000,2000);
			} else
				if(!inventoryContains(NOTES) && distanceTo(tile3) < 10 && !inventoryContains(RESEARCH_PACKAGE)
					&& !RSInterface.getInterface(243).isValid()
				 	&& !RSInterface.getInterface(230).isValid()
				 	&& !RSInterface.getInterface(65).isValid()
				 	&& !RSInterface.getInterface(210).isValid()
				 	&& !RSInterface.getInterface(242).isValid()
				 	&& !RSInterface.getInterface(230).isValid()
				 	&& !RSInterface.getInterface(244).isValid()) {
					log("Talking to Aubury #2");
					atNPC(Aubury, "Talk-to");
					return random(1000,2000); 
		} else
			if(Aubury != null && RSInterface.getInterface(230).getChild(4).getText().contains("been sent here"))  {
					atInterface(230, 4, "Continue");
					return random(1000,2000);
			} else 
				if(inventoryContains(NOTES) && Aubury != null) {
					try {
						log("Walking to Lumbridge");
						toAubury.walkToStart();
					} catch (InterruptedException e) {
					}
				}
	return 0;
	
	}
}

And you wanted the Noob Walker- Walk Anywhere In Runescape | [Author] Bob? Well, here it is.
Save as NoobWalker.java

import java.util.Map;
import com.speljohan.rsbot.script.Script;
import com.speljohan.rsbot.script.wrappers.RSTile;

public class NoobWalker extends Script {


    RSTile[] toGE = new RSTile[] { 
        new RSTile(3222, 3218), new RSTile(3224, 3218),
 	new RSTile(3234, 3222), new RSTile(3236, 3224),
 	new RSTile(3246, 3225), new RSTile(3256, 3228),
 	new RSTile(3259, 3238), new RSTile(3257, 3248),
 	new RSTile(3252, 3257), new RSTile(3249, 3267),
 	new RSTile(3242, 3275), new RSTile(3239, 3285),
 	new RSTile(3239, 3295), new RSTile(3239, 3305),
 	new RSTile(3246, 3313), new RSTile(3252, 3321),
 	new RSTile(3262, 3323), new RSTile(3254, 3330),
 	new RSTile(3244, 3335), new RSTile(3234, 3336),
 	new RSTile(3227, 3344), new RSTile(3226, 3354),
 	new RSTile(3218, 3362), new RSTile(3214, 3372),
 	new RSTile(3213, 3382), new RSTile(3213, 3392),
 	new RSTile(3212, 3402), new RSTile(3211, 3412),
 	new RSTile(3211, 3422), new RSTile(3210, 3425),
 	new RSTile(3200, 3428), new RSTile(3190, 3428),
 	new RSTile(3186, 3438), new RSTile(3180, 3447),
 	new RSTile(3172, 3455), new RSTile(3165, 3463),
 	new RSTile(3165, 3473), new RSTile(3165, 3483),
 	new RSTile(3164, 3487) };
    

    RSTile[] Path;
    
    RSTile[] Lumb_to_Dray = new RSTile[] { 
    new RSTile(3223, 3218), new RSTile(3232, 3224),
    new RSTile(3226, 3234), new RSTile(3215, 3237), 
    new RSTile(3204, 3237), new RSTile(3194, 3240), 
    new RSTile(3184, 3243), new RSTile(3174, 3241), 
    new RSTile(3163, 3236), new RSTile(3153, 3234), 
    new RSTile(3143, 3231), new RSTile(3133, 3224), 
    new RSTile(3123, 3219), new RSTile(3112, 3221), 
    new RSTile(3102, 3227), new RSTile(3094, 3235), 
    new RSTile(3098, 3246), new RSTile(3093, 3241) };
    
    public String getName() {
        return "Noob Walker";
    }
    
    public String getScriptCategory() {
        return "Bob/Noob Series";
    }

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

    public double getVersion() {
        return 1.4;
    }

    public boolean onStart(Map<String,String> args) {
        String destiny = args.get("to");
        if (destiny.equals("Lumbridge")) {
            RSTile origin = getMyPlayer().getLocation();
			if(origin != null && distanceBetween(origin, Lumb_to_Dray[Lumb_to_Dray.length-1]) < 10){
				Path = reversePath(Lumb_to_Dray);
			} else {
				Path = reversePath(toGE);
			}
			return true;
        } else if (destiny.equals("Grand Exchange")) {
            Path = toGE;
			return true;
        } else if(destiny.equals("Draynor")) {
            Path = Lumb_to_Dray;
			return true;
        }
		log("You didnt selected a valid Path to walk");
		return false;
    }

    public int loop() {
        if(distanceTo(Path[Path.length -1]) < 3) {
            return -1;
        }
		if(getEnergy() >= random(60, 80)) {
            if(!isRunning()) {	
				setRun(true);
				return random(1000, 2000);
			}
        }
		RSTile destination = getDestination();
		if(destination != null) {
			if(distanceTo(destination) > 5 ){
				return random(300, 800);
			}
		}
        walkPathMM(Path, 15);
        return random(800, 1500);
    }
        

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

        html += "<html>\n";
	html += "<head>\n";
	html += "<style type=\"text/css\"> body {background-image: url(\"http://i37.tinypic.com/wimx48.jpg\")}</style>";
	html += "<title>Noob Walker</title>\n";
	html += "</head>\n";
        html += "<body>\n";
        html += "<br>\n";
        html += "<br><br>\n";
        html += "<br><br>\n";
        html += "<br>";
        html += "<br>";
        html += "<br>";
        html += "<br><br><br><br><br><br><center>";
        html += "<select name=\"to\"> <option selected>Lumbridge<option>Grand Exchange<option>Draynor<option>Port Sarim<option>Falador<option>Rimmington</select>";
        html += "</body>\n";
        html += "</html\n";

        return( html );
    }
    
}

 

[kenzik]

Any one know when www.rsbot.org will be online ? i cant get there .

 

[gridfun]

Any one know when www.rsbot.org will be online ? i cant get there .

Its under construction, will be back in some hours.

 

[gridfun]

need Crafting Guild Gold Miner and banker please


Thanks Party_Dude

Start at Falador east bank.
Save as EliteMiner.java

//www.rsvids.net
import java.awt.*;
import java.util.*;
import javax.swing.*;
import com.speljohan.rsbot.bot.*;
import com.speljohan.rsbot.event.*;
import com.speljohan.rsbot.event.listeners.PaintListener;
import com.speljohan.rsbot.event.events.*;
import com.speljohan.rsbot.event.listeners.*;
import com.speljohan.rsbot.script.*;
import com.speljohan.rsbot.script.wrappers.*;
import java.awt.event.*;
import java.awt.event.KeyEvent;
import java.applet.Applet;

public class EliteMiner extends Script implements PaintListener {

	   public String getName( ) {
		      return( "Elite Miner" );
		   }

		   public double getVersion( ) {
		      return( 1.74 );
		   }

		   public String getAuthor( ) {
		      return( "$esame St" );
		   }


		   public String getScriptCategory() {
		      return( "$esame St/Elite Series" );
		   }

		   public String getScriptDescription( ) {

		      String html = "";

		      html += "<html>\n";
		      html += "<head>\n";
				html += "<style type=\"text/css\"> body {background-image: url(\"http://img32.picoodle.com/data/img32/3/9/7/f_guitm4m_7bc7dda.jpg\")}</style>";
				html += "</head>\n";
				html += "<body>\n";
				html += "<center>";
					html += "</center>\n";
					html += "<p\n";
					html += "<p\n";
					html += "<p\n";
	                html += "<center>";
	                html += "<font color=red>";
			html += "                        <b>Version:</b> " + getVersion() + "<p>\n";
			html += "</center>";
			html += "<font color=yellow>";
html += "<b>";
html += "<font face=Verdana>";
            html += "ELITE SERIES CREATED BY $ESAME ST! <p>\n";
html += "</b>";
html += "</font>";
            html += "<center>";
            html += "<font color=gray>";
            html += "                   Power or Bank Mode? <select name=\"power\"><option selected>Power<option>Bank</select> <br><br>";
					html += "Where are you mining at? <select name=\"wheretomine\"><option selected>Varrock East<option>Rimmington<option>Crafting Guild<option>Mining Guild<option>Barbarian Village<option>Al-Kharid<option>Draynor South<option>Not Listed</select> <br><br>";
					html += "What are you mining? <select name=\"whattomine\"><option selected>Tin & Copper<option>Clay<option>Iron<option>Coal<option>Silver<option>Gold<option>Mithril<option>Admantite<option>Mithril & Coal</select> <br><br>";
					html += "- No Arguments Needed!!! The ULTIMATE SCRIPT EVER FOR MINING <p>";
					html += "<p>\n";
	                html += "</center>";
						html += "</body>\n";
						html += "/<html>\n";
		      return( html );
		   }

		   private boolean BankOpen() {
		        return interfaceExists(INTERFACE_BANK);
		    }


	public final int[] smokingRocks = { 11433, 11434, 11435, 11436, 11437, 11438, 11439, 11440, 11441, 11168, 11169, 11170, 11174, 11176, 11177, 11178, 11179, 11180, 11181, 11182, 31116 };
	int				bankBooth;
	int				doorForPath;
	public int laddertop = 2113;
	public int ladderbottom = 30941;
	int				miningOre;
	int				checkTime;
	//RS Tiles
	RSTile[] 		toBank;
	RSTile[] 		LumbtoFally;
	RSTile[] 		LumbtoBarb;
	RSTile[] 		LumbtoDray;
	RSTile[] 		LumbtoVarrock;
	RSTile[] 		toCraftMine;
	RSTile[] 		toCraftDoor;
	RSTile[] 		toMine;
	RSTile[]		toVEastBank;
	RSTile[]		LumbtoAlk;
	long			startTime;
	long			lastCheck;
	int				fails;
	final int		MAX_FAILS			= 25;
	int				mode;
	boolean 		powerMode			= false;
	boolean 		bankMode			= false;
	boolean 		PowerOre			= false;
	boolean 		BankOre				= false;
	boolean 		VarrockMiner		= false;
	boolean 		CraftMiner		= false;
	boolean 		MineGMiner		= false;
	boolean 		RimmyMiner		= false;
	boolean 		DrayMiner		= false;
	boolean 		BarbMiner		= false;
	boolean 		AlkMiner		= false;
	int				randomRun			= random(40, 75);
	int				rockCount;
	int				oldRockCount;
	int				xpPerRock;
	long			avoidedCombat;
	long 			avoidedSmokingRocks;
	int				startLevel;
	int				startExp;
	int				oldExp;
	int				countToNext;
	int 			oldLevels;
	long			lastAvgCheck;
	int				avgPerHour;
	int 			gems;


	int[ ]			gear = new int[ ] {
			1265,			// Bronze Pick axe
			1267,			// Iron pick axe.
			1269,			// Steel Pick axe
			1273,			// Mithril Pick axe
			1271,			// Adamanite Pick axe.
			1275,			// Rune pick axe
			995,		// Money
			11021			// Test Item
		};



	public boolean onStart( Map<String, String> args ) {
		Bot.getEventManager( ).addListener(PaintListener.class, this);
		try {
			LumbtoFally = new RSTile[] { 	 new RSTile(3230, 3218),  new RSTile(3228, 3233),
					 new RSTile(3220, 3246),  new RSTile(3204, 3247),
					 new RSTile(3188, 3245),  new RSTile(3176, 3243),
					 new RSTile(3162, 3241),  new RSTile(3148, 3236),
					 new RSTile(3135, 3228),  new RSTile(3120, 3227),
					 new RSTile(3107, 3235),  new RSTile(3096, 3248),
					 new RSTile(3085, 3248),  new RSTile(3080, 3263),
					 new RSTile(3072, 3275),  new RSTile(3041, 3276),
					 new RSTile(3028, 3278),  new RSTile(3012, 3279),
					 new RSTile(3010, 3292),  new RSTile(3007, 3306),
					 new RSTile(3006, 3321),  new RSTile(3007, 3338),
					 new RSTile(3007, 3351),  new RSTile(3012, 3355)
				};
			LumbtoBarb = new RSTile[] { 	 	 new RSTile(3230, 3218),  new RSTile(3226, 3234),
					 new RSTile(3221, 3248),  new RSTile(3227, 3260),
					 new RSTile(3238, 3271),  new RSTile(3238, 3287),
					 new RSTile(3238, 3302),  new RSTile(3225, 3310),
					 new RSTile(3224, 3327),  new RSTile(3210, 3335),
					 new RSTile(3205, 3347),  new RSTile(3207, 3361),
					 new RSTile(3210, 3374),  new RSTile(3210, 3386),
					 new RSTile(3211, 3397),  new RSTile(3211, 3412),
					 new RSTile(3206, 3426),  new RSTile(3189, 3429),
					 new RSTile(3172, 3428),  new RSTile(3158, 3419),
					 new RSTile(3141, 3416),  new RSTile(3124, 3414),
					 new RSTile(3110, 3421),  new RSTile(3102, 3435),
					 new RSTile(3094, 3450),  new RSTile(3087, 3462),
					 new RSTile(3080, 3476),  new RSTile(3086, 3488),
					 new RSTile(3094, 3490)
				};
			LumbtoDray = new RSTile[] { 	 	 new RSTile(3226, 3218),  new RSTile(3228, 3232),
					 new RSTile(3219, 3237),  new RSTile(3208, 3245),
					 new RSTile(3192, 3246),  new RSTile(3177, 3245),
					 new RSTile(3162, 3240),  new RSTile(3153, 3234),
					 new RSTile(3138, 3228),  new RSTile(3122, 3223),
					 new RSTile(3109, 3227),  new RSTile(3099, 3238),
					 new RSTile(3092, 3243)
				};
			LumbtoVarrock = new RSTile[] { 	 	 new RSTile(3233, 3222),  new RSTile(3246, 3226),
					 new RSTile(3259, 3234),  new RSTile(3255, 3249),
					 new RSTile(3249, 3261),  new RSTile(3246, 3273),
					 new RSTile(3238, 3283),  new RSTile(3238, 3297),
					 new RSTile(3244, 3310),  new RSTile(3253, 3320),
					 new RSTile(3266, 3326),  new RSTile(3278, 3333),
					 new RSTile(3288, 3345),  new RSTile(3296, 3356),
					 new RSTile(3293, 3366),  new RSTile(3286, 3368)

				};
			LumbtoAlk = new RSTile[] { 	 	 	 new RSTile(3231, 3218),  new RSTile(3237, 3225),
					 new RSTile(3245, 3225),  new RSTile(3258, 3235),
					 new RSTile(3252, 3251),  new RSTile(3248, 3267),
					 new RSTile(3239, 3283),  new RSTile(3238, 3298),
					 new RSTile(3246, 3312),  new RSTile(3259, 3323),
					 new RSTile(3274, 3330),  new RSTile(3274, 3311),
					 new RSTile(3275, 3293),  new RSTile(3274, 3275),
					 new RSTile(3274, 3257),  new RSTile(3274, 3241),
					 new RSTile(3274, 3224),  new RSTile(3275, 3207),
					 new RSTile(3280, 3191),  new RSTile(3276, 3175),
					 new RSTile(3269, 3167)
				};
			if (args.get("wheretomine").equals("Varrock East")) {
				VarrockMiner = true;
				toBank = new RSTile[] { new RSTile(3288, 3368),
					   	 new RSTile(3295, 3379),  new RSTile(3292, 3389),
					   	 new RSTile(3291, 3401),  new RSTile(3288, 3414),
					   	 new RSTile(3285, 3425),  new RSTile(3277, 3430),
					   	 new RSTile(3265, 3429),  new RSTile(3257, 3429),
					   	 new RSTile(3253, 3422),  new RSTile(3253, 3420) };
				toMine = reversePath(toBank);
				log("WALKING PATH SET: [VARROCK EAST]");
				bankBooth = 11402;
			}
			if (args.get("wheretomine").equals("Mining Guild")) {
				MineGMiner = true;
				toBank = new RSTile[] {  	 new RSTile(3023, 3337),  new RSTile(3030, 3341),
						 new RSTile(3024, 3351),  new RSTile(3011, 3356)
				};
				toCraftMine = new RSTile[] {  	 new RSTile(3018, 9737), 	 new RSTile(3034, 9737),  new RSTile(3043, 9738)

};
				toCraftDoor = reversePath(toCraftMine);
				toMine = reversePath(toBank);
				log("WALKING PATH SET: [MINE GUILD]");
				bankBooth = 11758;
			}
			if (args.get("wheretomine").equals("Crafting Guild")) {
				CraftMiner = true;
				toBank = new RSTile[] {  new RSTile(2933, 3292),  new RSTile(2939, 3303),
						 new RSTile(2952, 3306),  new RSTile(2965, 3305),
						 new RSTile(2977, 3303),  new RSTile(2989, 3309),
						 new RSTile(3000, 3318),  new RSTile(3007, 3331),
						 new RSTile(3007, 3345),  new RSTile(3007, 3357),
						 new RSTile(3012, 3356)
					};
				toCraftMine = new RSTile[] {  new RSTile(2932, 3286),  new RSTile(2940, 3280)
				};
				toCraftDoor = reversePath(toCraftMine);
				toMine = reversePath(toBank);
				doorForPath = 2647;
				log("WALKING PATH SET: [CRAFT GUILD]");
				bankBooth = 11758;
			}
			if (args.get("wheretomine").equals("Rimmington")) {
				RimmyMiner = true;
				toBank = new RSTile[] {  new RSTile(2976, 3240),  new RSTile(2977, 3251),
				 new RSTile(2982, 3259),  new RSTile(2989, 3268),
				 new RSTile(3000, 3275),  new RSTile(3005, 3290),
				 new RSTile(3005, 3302),  new RSTile(3007, 3315),
				 new RSTile(3007, 3325),  new RSTile(3006, 3336),
				 new RSTile(3007, 3345),  new RSTile(3011, 3355) };
				log("WALKING PATH SET: [RIMMINGTON]");
				toMine = reversePath(toBank);
				bankBooth = 11758;
			}
			if (args.get("wheretomine").equals("Al-Kharid")) {
				AlkMiner = true;
				log("WALKING PATH SET: [AL-KHARID]");
				bankBooth = 35647;
			}
			if (args.get("wheretomine").equals("Draynor South")) {
				DrayMiner = true;
				toMine = new RSTile[] {  	 new RSTile(3094, 3248),  new RSTile(3099, 3233),
						 new RSTile(3111, 3220),  new RSTile(3123, 3209),
						 new RSTile(3136, 3202),  new RSTile(3141, 3187),
						 new RSTile(3142, 3172),  new RSTile(3145, 3157),
						 new RSTile(3147, 3148)
					};
				log("WALKING PATH SET: [DRAYNOR SOUTH]");
				toBank = reversePath(toMine);
				bankBooth = 2213;
			}
			if (args.get("wheretomine").equals("Barbarian Village")) {
				BarbMiner = true;
				toBank = new RSTile[] {  	 new RSTile(3090, 3432),  new RSTile(3091, 3448),
						 new RSTile(3090, 3460),  new RSTile(3079, 3471),
						 new RSTile(3082, 3484),  new RSTile(3091, 3490)
					};
				log("WALKING PATH SET: [BARB VILLAGE]");
				toMine = reversePath(toBank);
				bankBooth = 26972;
			}
			if (args.get("whattomine").equals("Tin & Copper")) {
				RockType = Ores;
				log("MINING ORE SET: [TIN & COPPER]");
				if (AlkMiner == true) {
					toBank = new RSTile[] { 					 					 new RSTile(3300, 3314),  new RSTile(3299, 3305),
							 new RSTile(3299, 3302),  new RSTile(3299, 3291),
							 new RSTile(3298, 3279),  new RSTile(3295, 3265),
							 new RSTile(3291, 3251),  new RSTile(3287, 3236),
							 new RSTile(3280, 3224),  new RSTile(3281, 3207),
							 new RSTile(3281, 3196),  new RSTile(3281, 3182),
							 new RSTile(3275, 3173),  new RSTile(3272, 3166),
							 new RSTile(3269, 3166)
						};
					toMine = reversePath(toBank);
				}
			}
			if (args.get("whattomine").equals("Iron")) {
				RockType = IOres;
				log("MINING ORE SET: [IRON]");
				if (AlkMiner == true) {
					toBank = new RSTile[] { 					 					 new RSTile(3300, 3314),  new RSTile(3299, 3305),
							 new RSTile(3299, 3302),  new RSTile(3299, 3291),
							 new RSTile(3298, 3279),  new RSTile(3295, 3265),
							 new RSTile(3291, 3251),  new RSTile(3287, 3236),
							 new RSTile(3280, 3224),  new RSTile(3281, 3207),
							 new RSTile(3281, 3196),  new RSTile(3281, 3182),
							 new RSTile(3275, 3173),  new RSTile(3272, 3166),
							 new RSTile(3269, 3166)
						};
					toMine = reversePath(toBank);
				}
			}
			if (args.get("whattomine").equals("Clay")) {
				RockType = CLOres;
				log("MINING ORE SET: [CLAY]");
				if (AlkMiner == true) {
					toBank = new RSTile[] { 					 					 new RSTile(3300, 3314),  new RSTile(3299, 3305),
							 new RSTile(3299, 3302),  new RSTile(3299, 3291),
							 new RSTile(3298, 3279),  new RSTile(3295, 3265),
							 new RSTile(3291, 3251),  new RSTile(3287, 3236),
							 new RSTile(3280, 3224),  new RSTile(3281, 3207),
							 new RSTile(3281, 3196),  new RSTile(3281, 3182),
							 new RSTile(3275, 3173),  new RSTile(3272, 3166),
							 new RSTile(3269, 3166)
						};
					toMine = reversePath(toBank);
				}
			}
			if (args.get("whattomine").equals("Coal")) {
				RockType = COres;
				log("MINING ORE SET: [COAL]");
				if (AlkMiner == true) {
					toBank = new RSTile[] { 					 new RSTile(3272, 3167),  new RSTile(3277, 3176),
							 new RSTile(3282, 3189),  new RSTile(3287, 3205),
							 new RSTile(3292, 3218),  new RSTile(3296, 3233),
							 new RSTile(3293, 3246),  new RSTile(3292, 3258),
							 new RSTile(3293, 3272),  new RSTile(3294, 3282),
							 new RSTile(3297, 3287),  new RSTile(3298, 3296),
							 new RSTile(3301, 3303)
						};
					toMine = reversePath(toBank);
					}
			}
			if (args.get("whattomine").equals("Silver")) {
				RockType = SOres;
				log("MINING ORE SET: [SILVER]");
				if (AlkMiner == true) {
					toBank = new RSTile[] { 					 					 new RSTile(3300, 3314),  new RSTile(3299, 3305),
							 new RSTile(3299, 3302),  new RSTile(3299, 3291),
							 new RSTile(3298, 3279),  new RSTile(3295, 3265),
							 new RSTile(3291, 3251),  new RSTile(3287, 3236),
							 new RSTile(3280, 3224),  new RSTile(3281, 3207),
							 new RSTile(3281, 3196),  new RSTile(3281, 3182),
							 new RSTile(3275, 3173),  new RSTile(3272, 3166),
							 new RSTile(3269, 3166)
						};
					toMine = reversePath(toBank);
				}
			}
			if (args.get("whattomine").equals("Gold")) {
				RockType = GOres;
				log("MINING ORE SET: [GOLD]");
				if (AlkMiner == true) {
					toBank = new RSTile[] { 					 new RSTile(3298, 3287),  new RSTile(3298, 3275),
							 new RSTile(3301, 3268),  new RSTile(3300, 3258),
							 new RSTile(3296, 3245),  new RSTile(3285, 3234),
							 new RSTile(3285, 3215),  new RSTile(3287, 3197),
							 new RSTile(3283, 3185),  new RSTile(3278, 3174),
							 new RSTile(3274, 3166),  new RSTile(3269, 3166)

						};
					toMine = reversePath(toBank);
				}
			}
			if (args.get("whattomine").equals("Mithril")) {
				RockType = MOres;
				log("MINING ORE SET: [MITHRIL]");
				if (AlkMiner == true) {
				toBank = new RSTile[] { 					 new RSTile(3272, 3167),  new RSTile(3277, 3176),
						 new RSTile(3282, 3189),  new RSTile(3287, 3205),
						 new RSTile(3292, 3218),  new RSTile(3296, 3233),
						 new RSTile(3293, 3246),  new RSTile(3292, 3258),
						 new RSTile(3293, 3272),  new RSTile(3294, 3282),
						 new RSTile(3297, 3287),  new RSTile(3298, 3296),
						 new RSTile(3301, 3303)
					};
				toMine = reversePath(toBank);
				}
			}
			if (args.get("whattomine").equals("Admantite")) {
				RockType = AOres;
				log("MINING ORE SET: [ADMANTITE]");
				if (AlkMiner == true) {
					toBank = new RSTile[] { 					 					 new RSTile(3300, 3314),  new RSTile(3299, 3305),
							 new RSTile(3299, 3302),  new RSTile(3299, 3291),
							 new RSTile(3298, 3279),  new RSTile(3295, 3265),
							 new RSTile(3291, 3251),  new RSTile(3287, 3236),
							 new RSTile(3280, 3224),  new RSTile(3281, 3207),
							 new RSTile(3281, 3196),  new RSTile(3281, 3182),
							 new RSTile(3275, 3173),  new RSTile(3272, 3166),
							 new RSTile(3269, 3166)
						};
					toMine = reversePath(toBank);
				}
			}
			if (args.get("whattomine").equals("Mithril & Coal")) {
				RockType = MCOres;
				log("MINING ORE SET: [MITH AND COAL]");
				toBank = new RSTile[] { 					 new RSTile(3272, 3167),  new RSTile(3277, 3176),
						 new RSTile(3282, 3189),  new RSTile(3287, 3205),
						 new RSTile(3292, 3218),  new RSTile(3296, 3233),
						 new RSTile(3293, 3246),  new RSTile(3292, 3258),
						 new RSTile(3293, 3272),  new RSTile(3294, 3282),
						 new RSTile(3297, 3287),  new RSTile(3298, 3296),
						 new RSTile(3301, 3303)
					};
			}
			if (args.get("wheretomine").equals("Not Listed")) {
				log("WALKING PATH SET: [NOT LISTED]");
			}
			if (args.get("power").equals("Power")) {
				powerMode = true;
				log("MINING MODE: [POWER]");
			}
		}
	 catch (Exception e) {
	 }
	 return true;
	 }

	public void checkForGas() {
		RSObject gas = findObject(smokingRocks);
		if (gas != null) {
			runAway();
		}
	}

	public void runAway() {
		RSTile run, run2;
		run = getMyPlayer().getLocation();
		setRun(true);
		run2 = new RSTile(run.getX() + random(8, 10), run.getY() + random(8, 10));
		walkTileMM(run2);
		wait(random(1000, 2000));
	}



    public void onFinish() {
	}

	private boolean walkPath2(RSTile[] path) {
		if (distanceTo(path[path.length - 1]) <= 2) {
			return true;
		} else {
			if (!getMyPlayer().isMoving()) {
				walkPathMM(randomizePath(path, 2, 2), 20);
			}
		}

		return false;
	}


	public void onRepaint( Graphics g ) {

		int	index = STAT_MINING;
		int exp = 0;
		int levels;
		long hours = 0, minutes = 0, seconds = 0;
		long time;


		if ( startTime == 0 ) {
			startTime = System.currentTimeMillis( );
		}


		time = System.currentTimeMillis( ) - startTime;
		seconds = (time / 1000);
		if ( seconds >= 60 ) {
			minutes = (seconds / 60);
			seconds -= (minutes * 60);
		}
		if ( minutes >= 60 ) {
			hours = (minutes / 60);
			minutes -= (hours * 60);
		}


		if ( startLevel == 0 || startExp == 0 ) {
			startLevel = skills.getCurrentSkillLevel( index );
			startExp = skills.getCurrentSkillExp( index );
			oldExp = 0;
		}


		exp = skills.getCurrentSkillExp( index ) - startExp;
		if ( exp > oldExp ) {
			xpPerRock = exp - oldExp;
			oldExp = exp;
			rockCount++;
			countToNext = (skills.getXPToNextLevel(STAT_MINING) / xpPerRock) + 1;
		}


		levels = skills.getCurrentSkillLevel( index ) - startLevel;
		if ( levels > oldLevels ) {
			oldLevels = levels;
		}


		if ( System.currentTimeMillis( ) - lastAvgCheck >= 60000 )  {
			lastAvgCheck = System.currentTimeMillis( );
			avgPerHour = (rockCount - oldRockCount) * 60;
			oldRockCount = rockCount;
		}


		g.setColor(Color.GREEN);
		g.drawString(getName( ) + " v" + getVersion( ), 9, 171);
		g.setColor(Color.WHITE);
		g.drawString("------------------", 9, 187);
g.setColor(Color.PINK);
		g.drawString("XP Gained: " + exp, 9, 203);
		g.drawString("Levels Gained: " + levels, 9, 219);
		g.drawString("Percent to next level: " + skills.getPercentToNextLevel( index ), 9, 235);
		g.drawString("Rocks: " + rockCount, 9, 251);
		g.drawString("Rocks to next level: " + countToNext, 9, 267);
		g.drawString("Time running: " + hours + ":" + minutes + "." + seconds, 9, 283);
		g.drawString("Runs: " + Runs, 9, 299);
		g.setColor(Color.WHITE);
		g.drawString("HELP CHANGE THE WORLD!!!", 9, 331);

		if (State == 0) {
			g.setColor(Color.PINK);
			g.drawString("State: Starting...", 9, 315);
		}
		if (State == 1) {
			g.setColor(Color.PINK);
			g.drawString("State: Mining...", 9, 315);
		}
		if (State == 2) {
			g.setColor(Color.PINK);
			g.drawString("State: Dropping/Walking...", 9, 315);
		}
		if (State == 3) {
			g.setColor(Color.PINK);
			g.drawString("State: Banking...", 9, 315);
		}
		if (State == 4) {
			g.setColor(Color.PINK);
			g.drawString("State: Walking...", 9, 315);
		}
		if (State == 6) {
			g.setColor(Color.PINK);
			g.drawString("State: Opening Door/Climing Ladder", 9, 315);
		}
		if (State == 7) {
			g.setColor(Color.PINK);
			g.drawString("State: Walking to Ladder/Door", 9, 315);
		}
		if (State == 8) {
			g.setColor(Color.PINK);
			g.drawString("State: Walking to Bank", 9, 315);
		}
		if (State == 9) {
			g.setColor(Color.PINK);
			g.drawString("State: Depositing Gear then Walking to Mine", 9, 315);
		}
		if (State == 10) {
			g.setColor(Color.PINK);
			g.drawString("State: Climbing Ladder/Open Door", 9, 315);
		}
		if (State == 11) {
			g.setColor(Color.PINK);
			g.drawString("State: Walking to Mine", 9, 315);
		}

		if (State == 12) {
			g.setColor(Color.PINK);
			g.drawString("State: Opening Bank", 9, 315);
		}
		if (State == 15) {
			g.setColor(Color.PINK);
			g.drawString("State: Walking to Mine/Bank from Lumby", 9, 315);
		}

	}

	private int StuffUps = 0;
    private int State = 0;  //This is gonna be THE variable that says in which state of the script we are
    private int[] Ores = {11957,11958,11959,11960,11961,11962,9708,9709,9710,9714,9716,11957,11958,11959,11936,11937,11938};
    private int[] IOres = {9717,9718,9719,11954,11955,11956,11954,11955,37307,37309};
    private int[] COres = {11930,11931,11932,31068,31069,31070};
    private int[] SOres = {11949,11950,37304,37305};
    private int[] GOres = {9720,9722,37310,37313,11183,11184,11184,11185};
    private int[] MOres = {11942,11944,31087,31088,31086};
    private int[] MCOres = {11942,11944,31087,31088,31086,11930,11932,31068,31069,31070};
    private int[] AOres = {11939,11941};
    private int[] CLOres = {11189,11190};
	public static final int[] pickaxeHeads = new int[] { 480, 482, 484, 486, 488, 490 };
	public static final int[] pickaxeTypes = new int[] { 1275, 1265, 1269, 1267, 1273, 1271 };
	public static final int[] pickaxeBrokens = new int[] { 468, 470, 472, 474, 476, 478 };
    private int[] Logs = {434,436,438,440,442,444,447,449,451,453};
    private int Runs = 0;
    private int RockType[];

	public void minestuff() {
		RSObject rock = findObject(RockType);
		if(rock != null) {
			atObject(rock, "Mine");
		}
		rotatecamera();
	}


    public int loop() {
    	try {
            RSObject upladder = findObject(ladderbottom);
            RSObject downladder = findObject(laddertop);
    		if(getEnergy() >= 95) {
    			setRun(true);
    		}

        	if(distanceTo(new RSTile(3222, 3219)) < 8) {
        		State = 15;
        	}

        	checkForPick();
        	checkForGas();

        switch (State) {
    	case 0:


    		JOptionPane.showMessageDialog(null, "ANIMAL SLAUGHTER IS WRONG PLEASE HELP US STOP ANIMAL SLAUGHTER IN THE WORLD!!! We Have One Chance To Make Things Right!!!");
        	log("Starting Up...");

        	if(distanceTo(new RSTile(3013, 3357)) < 5) {
        		if (RimmyMiner == true) {
        			State = 3;
        		}
        		else if (CraftMiner == true) {
        			State = 12;
        		}

        		else if (MineGMiner == true) {
            		State = 12;
        		}

        	}

        	if(distanceTo(new RSTile(3253, 3420)) < 5) {
        		State = 3;
        	}

        	if(distanceTo(new RSTile(3093, 3495)) < 10) {
        		State = 3;
        	}

        	if(distanceTo(new RSTile(3092, 3244)) < 5) {
        		State = 3;
        	}

        	if(distanceTo(new RSTile(3269, 3167)) < 5) {
        		State = 3;
        	}

        	else {
            	State++;
        	}
    	return random(50, 100);
            case 1:
                RSObject srock = findObject(smokingRocks);
                if(isInventoryFull()) {
                	State++;
                    } else {
                    		minestuff();
							antiBan();
                    }

                return random(1000, 2000);
            case 2:
            	if(isInventoryFull()) {
            	if (powerMode == true) {
                        State++;
                        Runs++;
                    	dropAllExcept( gear );
            			return random(500, 750);
                    } else {
                     	if (VarrockMiner == true) {
                     		if (walkPath(toBank)) {
                     			State++;

                     			}
                     	}
                     	else if (BarbMiner == true) {
                     		if (walkPath(toBank)) {
                     			State++;

                     			}
                     	}
                     	else if (RimmyMiner == true) {
                     		if (walkPath(toBank)) {
                     			State++;

                     			}
                     	}
                     	if (AlkMiner == true) {
                     		if (walkPath(toBank)) {
                     			State++;

                     			}
                     }
                     	else if (DrayMiner == true) {
                      		if (walkPath(toBank)) {
                     			State++;
                     			}
                     }
                     	else if (CraftMiner == true) {
                    		State = 7;
                    	}
                    	else if(MineGMiner == true) {
                    		State = 7;
                    	}
                     			return random(1000, 2000);
                     	}
}
                return random(1000, 2000);

            	   case 3:
            		   RSObject booth = findObject(bankBooth);
            		   if (powerMode == true) {
            			   State++;
            		   }

            		   if(!interfaceExists(762)) {
            			   rotatecamera();
        				atObject(booth, "Use-quickly");
        				}
            		   else if(interfaceExists(762)) {
            			   State++;
            			   return random(1000, 2000);
            			   }


            			   return random(1000, 2000);
                   case 4:
                	   if (powerMode == true) {
                		   State++;
                	   } else {
                		   if(interfaceExists(762)) {
                        	if (VarrockMiner == true) {
                		   bank.depositAllExcept(gear);
                		   if (walkPath(toMine)) {
                   			Runs++;
                		   State++;
                        	}
                        	}
                        	else if (BarbMiner == true) {
                        		   bank.depositAllExcept(gear);
                        		   if (walkPath(toMine)) {
                           			Runs++;
                        		   State++;
                                	}
                			   }
                        	else if (RimmyMiner == true) {
                     		   bank.depositAllExcept(gear);
                     		  if (walkPath(toMine)) {
                        			Runs++;
                     		   State++;
                		   }
                           	}
                        	else if (AlkMiner == true) {
                      		   bank.depositAllExcept(gear);
                      		  if (walkPath(toMine)) {
                         			Runs++;
                      		   State++;
                 		   }
                            	}
                            	else if (DrayMiner == true) {
                             		bank.depositAllExcept(gear);
                            		if (walkPath(toMine)) {
                            			State++;
                            			}
                              }
                            } else if(!interfaceExists(762)) {
                            	State--;
                            }
                	   }
                   	return random(1000, 2000);

        case 5:
                log("Runs: " + Runs);
                State = 1;
            	return random(1000, 2000);
            	        case 6:
            	        	if(CraftMiner == true ) {
            	        	RSObject door = findObject(doorForPath);
            	        	if (tileOnScreen(door.getLocation())) {
					atObject(door, "Open");
					State = 14;
					return random(750, 1000);
				}
            	        	 else {
					walkTileRand(door.getLocation());
					return random(500, 750);
				}
            	        	}


            	        	else if(MineGMiner == true) {
                	        	if (tileOnScreen(upladder.getLocation())) {
    					atObject(upladder, "Climb-up");
						wait(random(5000, 5000));
    					State = 14;
    					return random(750, 1000);
    				} else {
    					walkTileRand(upladder.getLocation());
    					return random(500, 750);
    				}
            	        	}
    case 7:
    	if(CraftMiner == true ) {
    	}
    	else if(MineGMiner == true) {
    	}
    	if (walkPath(toCraftDoor)) {
    		State = 6;
    	}

    	return random(1000, 2000);
case 8:
	if (walkPath(toBank)) {
		State = 12;
	}
	return random(1000, 2000);

case 9:
		   bank.depositAllExcept(gear);
	if (walkPath(toMine)) {
		State = 10;
	}


	return random(1000, 2000);

	case 10:
		if(CraftMiner == true ) {
		RSObject doorty = findObject(doorForPath);
		if (tileOnScreen(doorty.getLocation())) {
				atObject(doorty, "Open");
				State = 13;
				Runs++;
				return random(750, 1000);
			} else {
				walkTileRand(doorty.getLocation());
				return random(500, 750);
			}
		}

		if(MineGMiner == true) {
        	if (tileOnScreen(downladder.getLocation())) {
	atObject(downladder, "Climb-down");
	wait(random(4000, 5000));
	State = 13;
	return random(750, 1000);
} else {
	walkTileRand(downladder.getLocation());
	return random(500, 750);
}
    	}
    	return random(1000, 2000);

    case 11:
    	if (walkPath(toCraftMine)) {
    		State = 1;
    	}
    	return random(1000, 2000);


    case 12:
		   RSObject boothy = findObject(bankBooth);
		   if(BankOpen()){
			   State = 9;
			   return random(1000, 2000);
			   }
		   if (boothy != null) {
			if (tileOnScreen(boothy.getLocation())) {
				if (!atObject(boothy, "Use-quickly")) {
		   }

		   }
			}

			   return random(1000, 2000);

    case 13:
    	if(CraftMiner == true ) {
    	if(getMyPlayer().getLocation().equals(new RSTile(2933, 3288))) {
    	State = 11;
    	} else {
    		rotatecamera();
    		State = 10;
    	}
    	}
    	else if(MineGMiner == true) {
    		if(distanceTo(downladder) > 30) {
    			State = 11;
    		} else {
        		rotatecamera();
        		State = 10;
    	}
    	}
    	return random(1000, 2000);

    case 14:
    	if(CraftMiner == true ) {
    	if(getMyPlayer().getLocation().equals(new RSTile(2933, 3289))) {
    	State = 8;
    	} else {
    		rotatecamera();
    		State = 6;
    	}
    	}
    	else if(MineGMiner == true) {
    		if(distanceTo(upladder) > 30) {
    			State = 8;
    		} else {
        		rotatecamera();
        		State = 6;
    	}
    	}
    	return random(1000, 2000);

    case 15:
    	if (CraftMiner == true) {
    		if (walkPath(LumbtoFally)) {
        		State = 12;
    		}
    	}
    	else if (BarbMiner == true) {
    		if (walkPath(LumbtoBarb)) {
        		State = 3;
    		}
    	}
    	else if(MineGMiner == true) {
    		if (walkPath(LumbtoFally)) {
    			State = 12;
    		}
    	}
    	else if(DrayMiner == true) {
    		if (walkPath(LumbtoDray)) {
    			State = 3;
    		}
    	}
    	else if(RimmyMiner == true) {
    	if (walkPath(LumbtoFally)) {
    		State = 3;
    	}
    	}
    	else if (VarrockMiner == true) {
        		if (walkPath(LumbtoVarrock)) {
        			State = 1;
        		}
        	}
    	else if (AlkMiner == true) {
    		if (walkPath(LumbtoAlk)) {
    			State = 3;
    		}
    	}
        	return random(1000, 2000);

        }
    }
        catch(Exception e){
            e.printStackTrace();
            }
        return random(1000, 2000);
}

	private int antiBan() {
		int gamble = random(1, 12);

		switch (gamble) {
			case 1:
				return random(500, 750);

			case 2:
				int x = random(0, 750);
				int y = random(0, 500);
				moveMouse(0, 0, x, y);
				return random(500, 750);

			case 3:
				openTab(TAB_INVENTORY);
				return random(500, 750);

			case 4:
				if (getMyPlayer().isMoving()) {
					return random(750, 1000);
				}

				if (System.currentTimeMillis() - lastCheck >= checkTime) {
					lastCheck = System.currentTimeMillis();
					checkTime = random(60000, 180000);

					if (getCurrentTab() != TAB_STATS) {
						openTab(TAB_STATS);
					}
					moveMouse(660, 227, 50, 28);
					return random(5000, 8000);
				}

			case 5:
				if (random(1, 8) == 2) {
					int angle = getCameraAngle() + random(-90, 90);
					if (angle < 0) {
						angle = 0;
					}
					if (angle > 359) {
						angle = 0;
					}

					setCameraRotation(angle);
				}

				return random(500, 750);
		}

		return random(500, 750);
	}

	public void rotatecamera() {
		int rotatedegrees = random(0, 0);
		setCameraRotation(rotatedegrees);
	}

	private boolean walkPath(RSTile[] path) {
		if (distanceTo(path[path.length - 1]) <= 2) {
			return true;
		} else {
			if (!getMyPlayer().isMoving()) {
				walkPathMM(randomizePath(path, 2, 2), 20);
			}
		}

		return false;
	}

	public void smokingRockDetection() {
		RSTile run, run2;
		run = getMyPlayer().getLocation();
		setRun(true);
		run2 = new RSTile(run.getX() + random(8, 10), run.getY() + random(8, 10));
		walkTileMM(run2);
		wait(random(1000, 2000));
	}

	  public void checkForPick() {
			RSItemTile pickhead = getGroundItemByID(pickaxeHeads);
			if(pickhead != null) {
				atTile(pickhead, "Take");
			}
			if(inventoryContains(pickaxeHeads) && !inventoryContains(466)) {
				openTab(4);
				atInterface(83, 0);
			}
			if(inventoryContains(pickaxeHeads) && inventoryContains(466)) {
			RSItem pickaxehead = getInventoryItemByID(pickaxeHeads);
			RSItem pickaxehandle = getInventoryItemByID(466);
			RSItem pickaxetype = getInventoryItemByID(pickaxeTypes);
				useItem(pickaxehead, pickaxehandle);
				wait(random(1000, 15000));
				if(inventoryContains(1275)) {
					atInventoryItem(1275, "Wield");
				}
				if(inventoryContains(1265)) {
					atInventoryItem(1265, "Wield");
				}
				if(inventoryContains(1269)) {
					atInventoryItem(1269, "Wield");
				}
				if(inventoryContains(1267)) {
					atInventoryItem(1267, "Wield");
				}
				if(inventoryContains(1273)) {
					atInventoryItem(1273, "Wield");
				}
				if(inventoryContains(1271)) {
					atInventoryItem(1271, "Wield");
				}
			}
		}

	private void walkTileRand(RSTile tile) {
		// Local objects:
		RSTile temp = new RSTile(tile.getX() + random(-2, 2), tile.getY()
				+ random(-2, 2));

		walkTileMM(temp);
	}

}

 

[eevus]

The link to Chaos Temple Bone Burier doesn't work.

 

[gridfun]

The link to Chaos Temple Bone Burier doesn't work.

Mabey, this will help

import com.speljohan.rsbot.script.*;
import com.speljohan.rsbot.script.wrappers.*;
import com.speljohan.rsbot.script.wrappers.RSItemTile;

//Importing all the Script functions and Wrappers (Objects, NPC's, Characters)


public class AltarBurierv1 extends Script { //Declaring name + saying it's a script (filename should be same as the part between class and extends eg. ScriptBase.java)

public AltarBurierv1() {
setParameter("name", "Chaos Altar Bone Burier"); // Name of the Script
setParameter("version", 1); // Version of the Script
setParameter("author", "Assasins Cried"); // Author of the Script
setParameter("category", "Prayer"); // Category of the Script
setParameter("description", "<html>\n" +
"<head></head>\n" +
"<body>\n" +
"<center>" +
"<h2>" + getName() + "</h2>" +
"</center>\n" +
"<p\n" +
"<b>Author:</b> " + getAuthor() + "<p>\n" +
"<b>Version:</b> " + getVersion() + "<p>\n" +
"Bone Burying script made using darkmaxxie's scripting tutorial\n" +
"<p>\n" +
"</body>\n" +
"</html>");
}

public boolean onStart(String[] args) { //First thing run, when a Script is started (holds an array called "args" which contain the arguments put in by user in Script Selector
return true; //return true = Start Script; return false = Don't Start Script
}


private int Runs = 1;
private int State = 0; //This is gonna be THE variable that says in which state of the script we are
private int BonesID = 526;


public int loop() {
try{
switch (State) {
case 0: //start bone collecting
if (getInventoryCount() == 28) { //full inventory of bones, start next stage
State++;
} else { //Don't have full inventory, start collecting bones
for(int I=0;I<21;I++) { //finds nearest bones
RSItemTile BonesItemTile = getGroundItemByID(I,BonesID);
atTile(BonesItemTile, "Take Bones");//search for and pick up bones
}
return random(1000, 2000); } //Went to Next Step, Or has chopped a tree, Anyways, return to top.
case 1: //The Dropping
if(getInventoryCount(BonesID) == 0){ //If we have an Empty inventory go to next step
State++; //Next Step
} else{ //If not
atInventoryItem(BonesID, "Bury"); //Drop a log
}
return random(500, 1200); //Went to Next Step, Or has dropped log, return to top
case 2: //Runs output
System.out.println("Runs: " + Runs++); //Prints a line saying "Runs " followed by the number of runs.
State = 0; //Back to the start
return random(500, 1200); //return to top
}
}catch(Exception e){
e.printStackTrace();
}
return random(1000, 2000);
}
}

 

[Sindrefyrn]

Nice collection of scrips
Thank you.

 

[skipper132]

the newt buyer cant open the door to the shop

 

[enehmee]

is there a rsbot script for karamja fishing, that doesnt get stuck on the boat?

 

[IcyDude]

i need a good, minimizeable alcher that can work along with Rsbot antibans with overnight capabillities

 

[deadlywario0]

I need a Plank Maker that ACTUALLY WORKS mine gets stuck in the bank and starts taking out random items that arent in the first slot.....please post! ty

 

[deadlywario0]

AND can you please make it already configured, so i plug it in and it works...unlike the scrips above, my computer doesnt compress anything lol, thanks