PageRenderTime 63ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 1ms

/scripts/SS7AddyMiner.java

http://d-linked.googlecode.com/
Java | 2462 lines | 2218 code | 202 blank | 42 comment | 655 complexity | 66f1c96792c5d049ef2c2d70d638a293 MD5 | raw file
Possible License(s): GPL-3.0

Large files files are truncated, but you can click here to view the full file

    

  1. import java.awt.Color;
    2. 

  2. import java.awt.Font;
    3. 

  3. import java.awt.Graphics;
    4. 

  4. import java.awt.Point;
    5. 

  5. import java.awt.event.KeyEvent;
    6. 

  6. import java.io.BufferedReader;
    7. 

  7. import java.io.File;
    8. 

  8. import java.io.FileInputStream;
    9. 

  9. import java.io.FileOutputStream;
    10. 

  10. import java.io.IOException;
    11. 

  11. import java.io.InputStreamReader;
    12. 

  12. import java.lang.reflect.Method;
    13. 

  13. import java.net.URL;
    14. 

  14. import java.net.URLConnection;
    15. 

  15. import java.util.ArrayList;
    16. 

  16. import java.util.Map;
    17. 

  17. import java.util.Properties;
    18. 

  18. import java.util.logging.Level;
    19. 

  19. 

  20. import javax.swing.JOptionPane;
    21. 

  21. 

  22. import org.rsbot.bot.Bot;
    23. 

  23. import org.rsbot.bot.input.Mouse;
    24. 

  24. import org.rsbot.event.events.ServerMessageEvent;
    25. 

  25. import org.rsbot.event.listeners.PaintListener;
    26. 

  26. import org.rsbot.event.listeners.ServerMessageListener;
    27. 

  27. import org.rsbot.gui.AccountManager;
    28. 

  28. import org.rsbot.script.Calculations;
    29. 

  29. import org.rsbot.script.Constants;
    30. 

  30. import org.rsbot.script.GrandExchange;
    31. 

  31. import org.rsbot.script.Script;
    32. 

  32. import org.rsbot.script.ScriptManifest;
    33. 

  33. import org.rsbot.script.randoms.WelcomeScreen;
    34. 

  34. import org.rsbot.script.wrappers.RSInterface;
    35. 

  35. import org.rsbot.script.wrappers.RSInterfaceComponent;
    36. 

  36. import org.rsbot.script.wrappers.RSObject;
    37. 

  37. import org.rsbot.script.wrappers.RSTile;
    38. 

  38. import org.rsbot.util.GlobalConfiguration;
    39. 

  39. 

  40. @ScriptManifest(authors = { "SS7" }, category = "Mining", name = "SS7's Adamantite And Mithril Miner", version = 4.04, description = "<html><head><style type=\"text/css\"> hr {color: white} p {margin-left: 20px}</style></head><body><center><b><font size=\"4\" color=\"black\">All setting's can be configured in the GUI</font></b></table></center></body></html>")
    41. 

  41. public class SS7AddyMiner extends Script implements PaintListener,
    42. 

  42. 	ServerMessageListener {
    43. 

  43. 

  44.     class SS7AddyMinerSettings {
    45. 

  45. 	final File settingsFile = new File(new File(GlobalConfiguration.Paths
    46. 

  46. 		.getSettingsDirectory()), SETTINGS_FILE_NAME);
    47. 

  47. 

  48. 	String oreToMine = "";
    49. 

  49. 	String location = "";
    50. 

  50. 	String miningMethod = "";
    51. 

  51. 	String antibanSpeed = "";
    52. 

  52. 

  53. 	boolean allWorlds = false;
    54. 

  54. 	int[] worlds = new int[50];
    55. 

  55. 

  56. 	boolean superheat = false;
    57. 

  57. 	boolean mithBars = false;
    58. 

  58. 	boolean addyBars = false;
    59. 

  59. 	boolean alch = false;
    60. 

  60. 	boolean alchGems = false;
    61. 

  61. 	boolean alchBars = false;
    62. 

  62. 	boolean alchOres = false;
    63. 

  63. 	boolean alchCoal = false;
    64. 

  64. 

  65. 	boolean member = false;
    66. 

  66. 	boolean showPaint = false;
    67. 

  67. 	boolean useRest = false;
    68. 

  68. 	boolean dropGems = false;
    69. 

  69. 	boolean dropDiamonds = false;
    70. 

  70. 	boolean dropRubies = false;
    71. 

  71. 	boolean dropEmeralds = false;
    72. 

  72. 	boolean dropSapphires = false;
    73. 

  73. 

  74. 	String reportSetting = "";
    75. 

  75. 

  76. 	public SS7AddyMinerSettings() {
    77. 

  77. 	}
    78. 

  78. 

  79. 	public String booleanToString(final boolean a) {
    80. 

  80. 	    if (a) {
    81. 

  81. 		return "true";
    82. 

  82. 	    } else {
    83. 

  83. 		return "false";
    84. 

  84. 	    }
    85. 

  85. 	}
    86. 

  86. 

  87. 	public boolean extractBoolean(final String text) {
    88. 

  88. 	    return text.equals("true");
    89. 

  89. 	}
    90. 

  90. 

  91. 	public int[] extractIntegers(String text) {
    92. 

  92. 	    int[] ints = null;
    93. 

  93. 	    try {
    94. 

  94. 		text = text.replaceAll(" ", "");
    95. 

  95. 		final String[] strInts = text.split(",");
    96. 

  96. 		ints = new int[strInts.length];
    97. 

  97. 		for (int a = 0; a < strInts.length; a++) {
    98. 

  98. 		    ints[a] = Integer.parseInt(strInts[a]);
    99. 

  99. 		}
    100. 

  100. 	    } catch (final Exception e) {
    101. 

  101. 		log.log(Level.SEVERE, "extractIntegers(String) error: ", e);
    102. 

  102. 	    }
    103. 

  103. 	    return ints;
    104. 

  104. 	}
    105. 

  105. 

  106. 	public String[] extractStrings(final String text) {
    107. 

  107. 	    return text.split(",");
    108. 

  108. 	}
    109. 

  109. 

  110. 	public String getSetting(final String settingName) {
    111. 

  111. 	    try {
    112. 

  112. 		final Properties p = new Properties();
    113. 

  113. 		p.load(new FileInputStream(settingsFile));
    114. 

  114. 		return p.getProperty(settingName);
    115. 

  115. 	    } catch (final IOException ioe) {
    116. 

  116. 		log.log(Level.SEVERE, "loadSettings(String) error: ", ioe);
    117. 

  117. 		return "";
    118. 

  118. 	    }
    119. 

  119. 	}
    120. 

  120. 

  121. 	public String[][] getSettingsArray() {
    122. 

  122. 	    final ArrayList<String[]> settingsArray = new ArrayList<String[]>();
    123. 

  123. 

  124. 	    settingsArray.add(new String[] { "ORETOMINE", oreToMine });
    125. 

  125. 	    settingsArray.add(new String[] { "MININGMETHOD", miningMethod });
    126. 

  126. 	    settingsArray.add(new String[] { "LOCATION", location });
    127. 

  127. 	    settingsArray.add(new String[] { "ANTIBANSPEED", antibanSpeed });
    128. 

  128. 

  129. 	    settingsArray.add(new String[] { "ALLWORLDS",
    130. 

  130. 		    booleanToString(allWorlds) });
    131. 

  131. 	    if (!allWorlds) {
    132. 

  132. 		settingsArray.add(new String[] { "WORLDS",
    133. 

  133. 			intArrayToString(worlds) });
    134. 

  134. 	    }
    135. 

  135. 

  136. 	    settingsArray.add(new String[] { "SUPERHEAT",
    137. 

  137. 		    booleanToString(superheat) });
    138. 

  138. 	    if (superheat) {
    139. 

  139. 		settingsArray.add(new String[] { "MITHBARS",
    140. 

  140. 			booleanToString(mithBars) });
    141. 

  141. 		settingsArray.add(new String[] { "ADDYBARS",
    142. 

  142. 			booleanToString(addyBars) });
    143. 

  143. 	    }
    144. 

  144. 	    settingsArray.add(new String[] { "ALCH", booleanToString(alch) });
    145. 

  145. 	    if (alch) {
    146. 

  146. 		settingsArray.add(new String[] { "ALCHGEMS",
    147. 

  147. 			booleanToString(alchGems) });
    148. 

  148. 		settingsArray.add(new String[] { "ALCHBARS",
    149. 

  149. 			booleanToString(alchBars) });
    150. 

  150. 		settingsArray.add(new String[] { "ALCHORES",
    151. 

  151. 			booleanToString(alchOres) });
    152. 

  152. 		settingsArray.add(new String[] { "ALCHCOAL",
    153. 

  153. 			booleanToString(alchCoal) });
    154. 

  154. 	    }
    155. 

  155. 

  156. 	    settingsArray.add(new String[] { "DROPGEMS",
    157. 

  157. 		    booleanToString(dropGems) });
    158. 

  158. 	    if (dropGems) {
    159. 

  159. 		settingsArray.add(new String[] { "DROPDIAMOND",
    160. 

  160. 			booleanToString(dropDiamonds) });
    161. 

  161. 		settingsArray.add(new String[] { "DROPRUBY",
    162. 

  162. 			booleanToString(dropRubies) });
    163. 

  163. 		settingsArray.add(new String[] { "DROPEMERALD",
    164. 

  164. 			booleanToString(dropEmeralds) });
    165. 

  165. 		settingsArray.add(new String[] { "DROPSAPPHIRE",
    166. 

  166. 			booleanToString(dropSapphires) });
    167. 

  167. 	    }
    168. 

  168. 	    settingsArray.add(new String[] { "USEREST",
    169. 

  169. 		    booleanToString(useRest) });
    170. 

  170. 	    settingsArray.add(new String[] { "SHOWPAINT",
    171. 

  171. 		    booleanToString(showPaint) });
    172. 

  172. 	    settingsArray
    173. 

  173. 		    .add(new String[] { "MEMBER", booleanToString(member) });
    174. 

  174. 

  175. 	    settingsArray.add(new String[] { "REPORTSETTING", reportSetting });
    176. 

  176. 

  177. 	    final String[][] stringArray = new String[settingsArray.size()][2];
    178. 

  178. 	    for (int a = 0; a < settingsArray.size(); a++) {
    179. 

  179. 		stringArray[a][0] = settingsArray.get(a)[0];
    180. 

  180. 		stringArray[a][1] = settingsArray.get(a)[1];
    181. 

  181. 	    }
    182. 

  182. 	    return stringArray;
    183. 

  183. 	}
    184. 

  184. 

  185. 	public String intArrayToString(final int[] array) {
    186. 

  186. 	    String intArray = null;
    187. 

  187. 	    try {
    188. 

  188. 		if (array.length > 0) {
    189. 

  189. 		    intArray = "";
    190. 

  190. 		    for (int a = 0; a < array.length; a++) {
    191. 

  191. 			if (array[a] != 0) {
    192. 

  192. 			    intArray += array[a];
    193. 

  193. 			    if (a != array.length - 1) {
    194. 

  194. 				intArray += ",";
    195. 

  195. 			    }
    196. 

  196. 			}
    197. 

  197. 		    }
    198. 

  198. 		    return intArray;
    199. 

  199. 		}
    200. 

  200. 	    } catch (final Exception e) {
    201. 

  201. 	    }
    202. 

  202. 	    return "";
    203. 

  203. 	}
    204. 

  204. 

  205. 	public void saveSettings(final String[][] settings) {
    206. 

  206. 	    try {
    207. 

  207. 		final Properties p = new Properties();
    208. 

  208. 

  209. 		settingsFile.createNewFile();
    210. 

  210. 		p.load(new FileInputStream(settingsFile));
    211. 

  211. 		for (final String[] setting : settings) {
    212. 

  212. 		    p.setProperty(setting[0], setting[1]);
    213. 

  213. 		}
    214. 

  214. 		final FileOutputStream out = new FileOutputStream(settingsFile);
    215. 

  215. 		p.store(out, "");
    216. 

  216. 	    } catch (final IOException ioe) {
    217. 

  217. 		log.log(Level.SEVERE, "saveSettings(String[][]) error: ", ioe);
    218. 

  218. 	    }
    219. 

  219. 	}
    220. 

  220. 

  221. 	public void setSettings() {
    222. 

  222. 	    try {
    223. 

  223. 		oreToMine = getSetting("ORETOMINE");
    224. 

  224. 		miningMethod = getSetting("MININGMETHOD");
    225. 

  225. 		location = getSetting("LOCATION");
    226. 

  226. 		antibanSpeed = getSetting("ANTIBANSPEED");
    227. 

  227. 

  228. 		allWorlds = extractBoolean(getSetting("ALLWORLDS"));
    229. 

  229. 		if (!allWorlds) {
    230. 

  230. 		    worlds = extractIntegers(getSetting("WORLDS"));
    231. 

  231. 		}
    232. 

  232. 

  233. 		superheat = extractBoolean(getSetting("SUPERHEAT"));
    234. 

  234. 		if (superheat) {
    235. 

  235. 		    mithBars = extractBoolean(getSetting("MITHBARS"));
    236. 

  236. 		    addyBars = extractBoolean(getSetting("ADDYBARS"));
    237. 

  237. 		}
    238. 

  238. 		alch = extractBoolean(getSetting("ALCH"));
    239. 

  239. 		if (alch) {
    240. 

  240. 		    alchGems = extractBoolean(getSetting("ALCHGEMS"));
    241. 

  241. 		    alchBars = extractBoolean(getSetting("ALCHBARS"));
    242. 

  242. 		    alchOres = extractBoolean(getSetting("ALCHORES"));
    243. 

  243. 		    alchCoal = extractBoolean(getSetting("ALCHCOAL"));
    244. 

  244. 		}
    245. 

  245. 

  246. 		dropGems = extractBoolean(getSetting("DROPGEMS"));
    247. 

  247. 		if (dropGems) {
    248. 

  248. 		    dropDiamonds = extractBoolean(getSetting("DROPDIAMOND"));
    249. 

  249. 		    dropRubies = extractBoolean(getSetting("DROPRUBY"));
    250. 

  250. 		    dropEmeralds = extractBoolean(getSetting("DROPEMERALD"));
    251. 

  251. 		    dropSapphires = extractBoolean(getSetting("DROPSAPPHIRE"));
    252. 

  252. 		}
    253. 

  253. 		useRest = extractBoolean(getSetting("USEREST"));
    254. 

  254. 		showPaint = extractBoolean(getSetting("SHOWPAINT"));
    255. 

  255. 		member = extractBoolean(getSetting("MEMBER"));
    256. 

  256. 	    } catch (final Exception e) {
    257. 

  257. 		log.log(Level.SEVERE, "setSettings error: ", e);
    258. 

  258. 	    }
    259. 

  259. 	}
    260. 

  260. 

  261. 	public boolean settingsExist() {
    262. 

  262. 	    return settingsFile.exists();
    263. 

  263. 	}
    264. 

  264. 

  265. 	public String stringArrayToString(final String[] array) {
    266. 

  266. 	    String strArray = null;
    267. 

  267. 	    try {
    268. 

  268. 		strArray = "";
    269. 

  269. 		if (array.length <= 0) {
    270. 

  270. 		    return "";
    271. 

  271. 		}
    272. 

  272. 		for (int a = 0; a < array.length; a++) {
    273. 

  273. 		    if (!array[a].equals(null) && !array[a].equals("")) {
    274. 

  274. 			strArray += array[a].trim();
    275. 

  275. 			if (a != array.length - 1) {
    276. 

  276. 			    strArray += ",";
    277. 

  277. 			}
    278. 

  278. 		    }
    279. 

  279. 		}
    280. 

  280. 	    } catch (final Exception e) {
    281. 

  281. 	    }
    282. 

  282. 	    return strArray;
    283. 

  283. 	}
    284. 

  284.     }
    285. 

  285. 

  286.     private class getMarketPrice implements Runnable {
    287. 

  287. 	public boolean stop;
    288. 

  288. 

  289. 	public void run() {
    290. 

  290. 	    while (!stop) {
    291. 

  291. 		try {
    292. 

  292. 		    addyPrice = ge.loadItemInfo(449).getMarketPrice();
    293. 

  293. 		    mithPrice = ge.loadItemInfo(447).getMarketPrice();
    294. 

  294. 		    diamondPrice = ge.loadItemInfo(1617).getMarketPrice();
    295. 

  295. 		    rubyPrice = ge.loadItemInfo(1619).getMarketPrice();
    296. 

  296. 		    emeraldPrice = ge.loadItemInfo(1621).getMarketPrice();
    297. 

  297. 		    sapphirePrice = ge.loadItemInfo(1623).getMarketPrice();
    298. 

  298. 		    stop = true;
    299. 

  299. 		} catch (Exception e) {
    300. 

  300. 		    e.printStackTrace();
    301. 

  301. 		}
    302. 

  302. 	    }
    303. 

  303. 	}
    304. 

  304.     }
    305. 

  305. 

  306.     private class SS7AddyMinerAntiBan implements Runnable {
    307. 

  307. 	public boolean stopThread;
    308. 

  308. 

  309. 	public void run() {
    310. 

  310. 	    while (!stopThread && isLoggedIn() && antiBanSpeed > 0) {
    311. 

  311. 		try {
    312. 

  312. 

  313. 		    if (random(0, 15) == 0) {
    314. 

  314. 			final char[] LR = new char[] { KeyEvent.VK_LEFT,
    315. 

  315. 				KeyEvent.VK_RIGHT };
    316. 

  316. 			final char[] UD = new char[] { KeyEvent.VK_DOWN,
    317. 

  317. 				KeyEvent.VK_UP };
    318. 

  318. 			final char[] LRUD = new char[] { KeyEvent.VK_LEFT,
    319. 

  319. 				KeyEvent.VK_RIGHT, KeyEvent.VK_UP,
    320. 

  320. 				KeyEvent.VK_UP };
    321. 

  321. 			final int random2 = random(0, 2);
    322. 

  322. 			final int random1 = random(0, 2);
    323. 

  323. 			final int random4 = random(0, 4);
    324. 

  324. 

  325. 			if (random(0, 3) == 0) {
    326. 

  326. 			    Bot.getInputManager().pressKey(LR[random1]);
    327. 

  327. 			    Thread.sleep(random(100, 400));
    328. 

  328. 			    Bot.getInputManager().pressKey(UD[random2]);
    329. 

  329. 			    Thread.sleep(random(300, 600));
    330. 

  330. 			    Bot.getInputManager().releaseKey(UD[random2]);
    331. 

  331. 			    Thread.sleep(random(100, 400));
    332. 

  332. 			    Bot.getInputManager().releaseKey(LR[random1]);
    333. 

  333. 			} else {
    334. 

  334. 			    Bot.getInputManager().pressKey(LRUD[random4]);
    335. 

  335. 			    if (random4 > 1) {
    336. 

  336. 				Thread.sleep(random(300, 600));
    337. 

  337. 			    } else {
    338. 

  338. 				Thread.sleep(random(500, 900));
    339. 

  339. 			    }
    340. 

  340. 			    Bot.getInputManager().releaseKey(LRUD[random4]);
    341. 

  341. 			}
    342. 

  342. 		    } else {
    343. 

  343. 			Thread.sleep(random(200, 2000));
    344. 

  344. 		    }
    345. 

  345. 		} catch (final Exception e) {
    346. 

  346. 		    e.printStackTrace();
    347. 

  347. 		}
    348. 

  348. 	    }
    349. 

  349. 	}
    350. 

  350.     }
    351. 

  351. 

  352.     SS7AddyMinerAntiBan antiban;
    353. 

  353.     Thread t;
    354. 

  354.     getMarketPrice price;
    355. 

  355.     Thread p;
    356. 

  356. 

  357.     // ROCK ID'S
    358. 

  358.     int[] ironRock = { 37307, 37308, 37309, 31071, 31072, 31073 };
    359. 

  359.     int[] addyRock = { 11941, 11939, 31083, 31085, 31083, 31085 };
    360. 

  360.     int[] coalRock = { 11930, 11931, 11932 };
    361. 

  361.     int[] mithRock = { 11944, 11943, 11942, 31086, 31088 };
    362. 

  362.     int[] mithAndAddyRock = { 11941, 11939, 31083, 31085, 31083, 31085, 11944,
    363. 

  363. 	    11943, 11942, 31086, 31088 };
    364. 

  364.     int[] oreToMine2;
    365. 

  365. 

  366.     // MINING
    367. 

  367.     RSTile lastRock = new RSTile(0000, 0000);
    368. 

  368.     int rocksteal = 0;
    369. 

  369.     int xrocksteal = 0;
    370. 

  370.     int rrocksteal = 0;
    371. 

  371.     int superheatError = 0;
    372. 

  372.     int wieldStaff = 0;
    373. 

  373.     int scroll = 2;
    374. 

  374.     int[] gems = { 1617, 1619, 1621, 1623 };
    375. 

  375.     int[] bars = { 2361, 2359 };
    376. 

  376.     private final int PASSWORD_INTERFACE = 457, USERNAME_INTERFACE = 451,
    377. 

  377. 	    TEXT_INTERFACE = 445;
    378. 

  378.     private int failSafeCount = 0;
    379. 

  379.     boolean checkMining = false;
    380. 

  380.     boolean checkSmithing = false;
    381. 

  381.     boolean checkMagic = false;
    382. 

  382.     int[] dontBank = { 1387, 561, 1265, 1267, 1269, 1271, 1273, 1275, 1296, 995 };
    383. 

  383.     int total;
    384. 

  384.     boolean done = false;
    385. 

  385.     private final String SETTINGS_FILE_NAME = "SS7AddyMinerSettings.txt";
    386. 

  386.     private final SS7AddyMinerSettings settings = new SS7AddyMinerSettings();
    387. 

  387.     String accountName;
    388. 

  388. 

  389.     private javax.swing.JCheckBox addyBars;
    390. 

  390.     private javax.swing.JCheckBox alch;
    391. 

  391.     private javax.swing.JCheckBox alchBars;
    392. 

  392.     private javax.swing.JCheckBox alchGOres;
    393. 

  393.     private javax.swing.JCheckBox alchGems;
    394. 

  394.     private javax.swing.JCheckBox alchSOres;
    395. 

  395.     private javax.swing.JComboBox antibanSpeed;
    396. 

  396.     private javax.swing.JButton cancelButton;
    397. 

  397.     private javax.swing.JCheckBox dropDia;
    398. 

  398.     private javax.swing.JCheckBox dropEme;
    399. 

  399.     private javax.swing.JCheckBox dropGems;
    400. 

  400.     private javax.swing.JCheckBox dropRub;
    401. 

  401.     private javax.swing.JCheckBox dropSapp;
    402. 

  402.     private javax.swing.JFrame jFrame1;
    403. 

  403.     private javax.swing.JLabel jLabel1;
    404. 

  404.     private javax.swing.JLabel jLabel10;
    405. 

  405.     private javax.swing.JLabel jLabel15;
    406. 

  406.     private javax.swing.JLabel jLabel2;
    407. 

  407.     private javax.swing.JLabel jLabel28;
    408. 

  408.     private javax.swing.JLabel jLabel3;
    409. 

  409.     private javax.swing.JLabel jLabel5;
    410. 

  410.     private javax.swing.JLabel jLabel6;
    411. 

  411.     private javax.swing.JLabel jLabel7;
    412. 

  412.     private javax.swing.JPanel jPanel2;
    413. 

  413.     private javax.swing.JPanel jPanel4;
    414. 

  414.     private javax.swing.JPanel jPanel5;
    415. 

  415.     private javax.swing.JPanel jPanel6;
    416. 

  416.     private javax.swing.JTabbedPane jTabbedPane2;
    417. 

  417.     private javax.swing.JTextField listOfWorlds;
    418. 

  418.     private javax.swing.JComboBox location;
    419. 

  419.     private javax.swing.JCheckBox member;
    420. 

  420.     private javax.swing.JCheckBox mithBars;
    421. 

  421.     private javax.swing.JComboBox oreToMine;
    422. 

  422.     private javax.swing.JCheckBox showPaint;
    423. 

  423.     private javax.swing.JButton startButton;
    424. 

  424.     private javax.swing.JCheckBox superheat;
    425. 

  425.     private javax.swing.JCheckBox useRest;
    426. 

  426.     private javax.swing.JButton visitThread;
    427. 

  427.     private javax.swing.JCheckBox worldCheck;
    428. 

  428.     private javax.swing.JComboBox worldhop;
    429. 

  429. 

  430.     // WORLD HOP STRINGS
    431. 

  431.     String customWorlds[];
    432. 

  432. 

  433.     // PATHS
    434. 

  434.     // ALKHARID
    435. 

  435.     RSTile[] bankToMine = new RSTile[] { new RSTile(3270, 3167),
    436. 

  436. 	    new RSTile(3276, 3174), new RSTile(3283, 3185),
    437. 

  437. 	    new RSTile(3282, 3196), new RSTile(3279, 3209),
    438. 

  438. 	    new RSTile(3277, 3220), new RSTile(3275, 3231),
    439. 

  439. 	    new RSTile(3278, 3242), new RSTile(3278, 3252),
    440. 

  440. 	    new RSTile(3282, 3262), new RSTile(3288, 3272),
    441. 

  441. 	    new RSTile(3296, 3279), new RSTile(3298, 3293),
    442. 

  442. 	    new RSTile(3300, 3304), new RSTile(3297, 3312) };
    443. 

  443.     RSTile[] mineToBank = reversePath(bankToMine);
    444. 

  444. 

  445.     // DRAYNOR
    446. 

  446.     RSTile[] cabbageToStile = new RSTile[] { new RSTile(3054, 3289),
    447. 

  447. 	    new RSTile(3058, 3288), new RSTile(3063, 3284) };
    448. 

  448.     RSTile[] stileToBank = new RSTile[] { new RSTile(3071, 3277),
    449. 

  449. 	    new RSTile(3073, 3271), new RSTile(3074, 3264),
    450. 

  450. 	    new RSTile(3076, 3257), new RSTile(3081, 3253),
    451. 

  451. 	    new RSTile(3086, 3249), new RSTile(3091, 3248),
    452. 

  452. 	    new RSTile(3092, 3244) };
    453. 

  453.     RSTile[] draynorToBank = new RSTile[] { new RSTile(3146, 3148),
    454. 

  454. 	    new RSTile(3150, 3153), new RSTile(3145, 3163),
    455. 

  455. 	    new RSTile(3141, 3171), new RSTile(3140, 3179),
    456. 

  456. 	    new RSTile(3139, 3186), new RSTile(3138, 3194),
    457. 

  457. 	    new RSTile(3135, 3201), new RSTile(3131, 3209),
    458. 

  458. 	    new RSTile(3123, 3215), new RSTile(3116, 3219),
    459. 

  459. 	    new RSTile(3108, 3223), new RSTile(3096, 3234),
    460. 

  460. 	    new RSTile(3093, 3243) };
    461. 

  461.     RSTile[] bankToDraynor = reversePath(draynorToBank);
    462. 

  462.     // FALADOR
    463. 

  463.     RSTile[] bankToDoor = new RSTile[] { new RSTile(3013, 3356),
    464. 

  464. 	    new RSTile(3012, 3360), new RSTile(3016, 3362),
    465. 

  465. 	    new RSTile(3022, 3364), new RSTile(3028, 3366),
    466. 

  466. 	    new RSTile(3034, 3368), new RSTile(3040, 3370),
    467. 

  467. 	    new RSTile(3047, 3369), new RSTile(3052, 3369),
    468. 

  468. 	    new RSTile(3057, 3370), new RSTile(3061, 3374),
    469. 

  469. 	    new RSTile(3061, 3377) };
    470. 

  470.     RSTile[] stairsToMine = new RSTile[] { new RSTile(3058, 9776),
    471. 

  471. 	    new RSTile(3052, 9774), new RSTile(3046, 9772),
    472. 

  472. 	    new RSTile(3039, 9773) };
    473. 

  473.     RSTile[] doorToBank = reversePath(bankToDoor);
    474. 

  474.     RSTile[] mineToStairs = reversePath(stairsToMine);
    475. 

  475.     // DEATHWALK
    476. 

  476.     RSTile[] alkharidDeathwalk = new RSTile[] {};
    477. 

  477.     RSTile[] draynorDeathwalk = new RSTile[] {};
    478. 

  478. 

  479.     // LOCATION BOOLEANS
    480. 

  480.     boolean draynor, alkharid, falador = false;
    481. 

  481. 

  482.     // ITEMS
    483. 

  483.     int[] thingsToKeep = { 1275, 449, 1623, 1621, 1619, 1617, 447, 1387, 561,
    484. 

  484. 	    2361, 2359, 995, 1265, 1267, 1269, 1271, 1273, 1275, 1296 };
    485. 

  485. 

  486.     // BANK ITEMS
    487. 

  487.     int[] bankBoothID = { 35647, 35648, 11758, 2213 };
    488. 

  488. 

  489.     // PAINT VARIABLES
    490. 

  490.     int startingXP, addyMined, mithMined, startingLevel, profit, levelsGained,
    491. 

  491. 	    moneyGained, currentXP, XPGained, currentLevel, nextLevel,
    492. 

  492. 	    XPTillNextLevel, oresTillNextLevel, avgXPHour, avgMoneyHour,
    493. 

  493. 	    avgOresHour, percentTillNextLevel, addyPrice, mithPrice,
    494. 

  494. 	    diamondPrice, rubyPrice, emeraldPrice, sapphirePrice, diamondMined,
    495. 

  495. 	    rubyMined, emeraldMined, sapphireMined = 0;
    496. 

  496.     long startTime;
    497. 

  497. 

  498.     // ANTIBAN VARIABLES
    499. 

  499.     int antiBanSpeed;
    500. 

  500. 

  501.     // STRINGS
    502. 

  502.     String status;
    503. 

  503. 

  504.     // LONGS
    505. 

  505.     long stairsUpTime = System.currentTimeMillis();
    506. 

  506.     long stairsDownTime = System.currentTimeMillis();
    507. 

  507. 

  508.     // OBJECTS
    509. 

  509.     RSObject rock;
    510. 

  510. 

  511.     // OPTIONS
    512. 

  512.     boolean member2, rest, paint, addy, mith, both, worldHop, diamond, ruby,
    513. 

  513. 	    emerald, sapphire, superheat2, alch2, addyBar, mithBar, alchG,
    514. 

  514. 	    alchB, alchGO, alchSO, ring = false;
    515. 

  515. 

  516.     // GUI
    517. 

  517.     boolean startScript = false;
    518. 

  518. 

  519.     // GRAND EXCHANGE
    520. 

  520.     final GrandExchange ge = new GrandExchange();
    521. 

  521. 

  522.     // STRING EXTRACTION
    523. 

  523.     public String[] extractStrings(final String text) {
    524. 

  524. 	return text.split(", ");
    525. 

  525.     }
    526. 

  526. 

  527.     // LOOP
    528. 

  528.     public boolean ableToCast() {
    529. 

  529. 	if (superheat2) {
    530. 

  530. 	    if (addyBar) {
    531. 

  531. 		if (getInventoryCount(449) >= 1 && getInventoryCount(453) >= 7) {
    532. 

  532. 		    return true;
    533. 

  533. 		}
    534. 

  534. 	    } else if (mithBar) {
    535. 

  535. 		if (getInventoryCount(447) >= 1 && getInventoryCount(453) >= 4) {
    536. 

  536. 		    return true;
    537. 

  537. 		}
    538. 

  538. 	    } else {
    539. 

  539. 		return false;
    540. 

  540. 	    }
    541. 

  541. 	}
    542. 

  542. 	return false;
    543. 

  543.     }
    544. 

  544. 

  545.     public boolean ableToAlch() {
    546. 

  546. 	if (alch2) {
    547. 

  547. 	    if (getInventoryCount() > random(22, 28)) {
    548. 

  548. 		if (alchG) {
    549. 

  549. 		    if (getInventoryCount(gems) > 0) {
    550. 

  550. 			return true;
    551. 

  551. 		    }
    552. 

  552. 		}
    553. 

  553. 		if (alchB) {
    554. 

  554. 		    if (getInventoryCount(bars) > 0) {
    555. 

  555. 			return true;
    556. 

  556. 		    }
    557. 

  557. 		}
    558. 

  558. 		if (alchGO) {
    559. 

  559. 		    if (getInventoryCount(449, 447) > 0) {
    560. 

  560. 			return true;
    561. 

  561. 		    }
    562. 

  562. 		}
    563. 

  563. 		if (alchSO) {
    564. 

  564. 		    if (getInventoryCount(453) > 0) {
    565. 

  565. 			return true;
    566. 

  566. 		    }
    567. 

  567. 		}
    568. 

  568. 	    } else {
    569. 

  569. 		return false;
    570. 

  570. 	    }
    571. 

  571. 	} else {
    572. 

  572. 	    return false;
    573. 

  573. 	}
    574. 

  574. 	return false;
    575. 

  575.     }
    576. 

  576. 

  577.     boolean s = false;
    578. 

  578. 

  579.     public int loop() {
    580. 

  580. 

  581. 	try {
    582. 

  582. 	    if (!t.isAlive()) {
    583. 

  583. 		t.start();
    584. 

  584. 	    }
    585. 

  585. 	} catch (Exception e) {
    586. 

  586. 

  587. 	}
    588. 

  588. 

  589. 	if (!s) {
    590. 

  590. 	    if (equipmentContains(13562)) {
    591. 

  591. 		ring = true;
    592. 

  592. 	    }
    593. 

  593. 	    s = true;
    594. 

  594. 	}
    595. 

  595. 

  596. 	antiBan();
    597. 

  597. 	runCheck();
    598. 

  598. 	dropGems();
    599. 

  599. 	combat();
    600. 

  600. 

  601. 	if (getMyPlayer().getAnimation() == 624) {
    602. 

  602. 	    status = "Mining";
    603. 

  603. 	}
    604. 

  604. 

  605. 	if ((checkMining) || (checkMagic) || (checkSmithing)) {
    606. 

  606. 	    if (random(-10, 10) > 0) {
    607. 

  607. 		clickStat();
    608. 

  608. 		checkMining = false;
    609. 

  609. 		checkMagic = false;
    610. 

  610. 		checkSmithing = false;
    611. 

  611. 	    } else {
    612. 

  612. 		checkMining = false;
    613. 

  613. 		checkMagic = false;
    614. 

  614. 		checkSmithing = false;
    615. 

  615. 	    }
    616. 

  616. 	}
    617. 

  617. 

  618. 	if (superheat2) {
    619. 

  619. 	    if (ableToCast()) {
    620. 

  620. 		castSuperHeat();
    621. 

  621. 		wait(random(200, 300));
    622. 

  622. 		lastRock = new RSTile(0, 0);
    623. 

  623. 	    }
    624. 

  624. 	}
    625. 

  625. 

  626. 	if (alch2) {
    627. 

  627. 	    if (ableToAlch()) {
    628. 

  628. 		Highalch();
    629. 

  629. 		wait(random(200, 300));
    630. 

  630. 		lastRock = new RSTile(0, 0);
    631. 

  631. 	    }
    632. 

  632. 	}
    633. 

  633. 

  634. 	if (isInventoryFull()) {
    635. 

  635. 	    if (worldHop) {
    636. 

  636. 		if (atBank()) {
    637. 

  637. 		    handleBank();
    638. 

  638. 		} else {
    639. 

  639. 		    status = "Walking To The Bank";
    640. 

  640. 		    walkToBank();
    641. 

  641. 		}
    642. 

  642. 	    } else {
    643. 

  643. 		if (getInventoryCount(thingsToKeep) >= 28) {
    644. 

  644. 		    if (atBank()) {
    645. 

  645. 			handleBank();
    646. 

  646. 		    } else {
    647. 

  647. 			status = "Walking To The Bank";
    648. 

  648. 			walkToBank();
    649. 

  649. 		    }
    650. 

  650. 		} else {
    651. 

  651. 		    status = "Dropping Ores";
    652. 

  652. 		    dropAllExcept(thingsToKeep);
    653. 

  653. 		}
    654. 

  654. 	    }
    655. 

  655. 	} else {
    656. 

  656. 	    if (atMine()) {
    657. 

  657. 		rockMining();
    658. 

  658. 	    } else {
    659. 

  659. 		status = "Walking To The Mine";
    660. 

  660. 		walkToMine();
    661. 

  661. 	    }
    662. 

  662. 	}
    663. 

  663. 	return random(400, 800);
    664. 

  664.     }
    665. 

  665. 

  666.     // ANTIBAN
    667. 

  667.     public void antiBan() {
    668. 

  668. 	if (antiBanSpeed != 0) {
    669. 

  669. 	    switch (random(0, antiBanSpeed)) {
    670. 

  670. 	    case 1:
    671. 

  671. 	    case 2:
    672. 

  672. 	    case 3:
    673. 

  673. 	    case 4:
    674. 

  674. 	    case 5:
    675. 

  675. 	    case 6:
    676. 

  676. 	    case 7:
    677. 

  677. 		moveMouse();
    678. 

  678. 		break;
    679. 

  679. 	    case 8:
    680. 

  680. 	    case 9:
    681. 

  681. 	    case 10:
    682. 

  682. 	    case 11:
    683. 

  683. 	    case 12:
    684. 

  684. 	    case 13:
    685. 

  685. 		turnCamera();
    686. 

  686. 		break;
    687. 

  687. 	    case 14:
    688. 

  688. 	    case 15:
    689. 

  689. 		openTab(Constants.TAB_STATS);
    690. 

  690. 		wait(random(200, 400));
    691. 

  691. 		if (random(-10, 10) > 0) {
    692. 

  692. 		    moveMouse(688, 246, 10, 10);
    693. 

  693. 		}
    694. 

  694. 		wait(random(800, 1200));
    695. 

  695. 		break;
    696. 

  696. 	    case 16:
    697. 

  697. 		openTab(Constants.TAB_FRIENDS);
    698. 

  698. 		wait(random(800, 1220));
    699. 

  699. 		break;
    700. 

  700. 	    case 17:
    701. 

  701. 		openTab(Constants.TAB_INVENTORY);
    702. 

  702. 		wait(random(1000, 2000));
    703. 

  703. 		break;
    704. 

  704. 	    case 18:
    705. 

  705. 		openTab(Constants.TAB_INVENTORY);
    706. 

  706. 		wait(random(1000, 2000));
    707. 

  707. 		openTab(Constants.TAB_STATS);
    708. 

  708. 		wait(random(200, 400));
    709. 

  709. 		moveMouse(688, 246, 5, 5);
    710. 

  710. 		wait(random(800, 1200));
    711. 

  711. 		break;
    712. 

  712. 	    case 19:
    713. 

  713. 		moveMouse(random(0, 800), random(0, 800));
    714. 

  714. 		wait(random(200, 400));
    715. 

  715. 		moveMouse(random(0, 800), random(0, 800));
    716. 

  716. 		wait(random(150, 300));
    717. 

  717. 		break;
    718. 

  718. 	    case 20:
    719. 

  719. 		int randomTab = random(1, 14);
    720. 

  720. 		openTab(randomTab);
    721. 

  721. 		break;
    722. 

  722. 	    case 22:
    723. 

  723. 		if (alch2) {
    724. 

  724. 		    if (ableToCast()) {
    725. 

  725. 			return;
    726. 

  726. 		    }
    727. 

  727. 		    Highalch();
    728. 

  728. 		}
    729. 

  729. 	    case 23:
    730. 

  730. 		if (superheat2) {
    731. 

  731. 		    castSuperHeat();
    732. 

  732. 		}
    733. 

  733. 	    }
    734. 

  734. 	}
    735. 

  735.     }
    736. 

  736. 

  737.     public void clickStat() {
    738. 

  738. 	openTab(TAB_STATS);
    739. 

  739. 	if (checkMining) {
    740. 

  740. 	    moveMouse(688, 246, 10, 10);
    741. 

  741. 	} else if (checkSmithing) {
    742. 

  742. 	    moveMouse(692, 278, 10, 10);
    743. 

  743. 	} else {
    744. 

  744. 	    moveMouse(580, 408, 10, 10);
    745. 

  745. 	}
    746. 

  746. 	clickMouse(true);
    747. 

  747. 	wait(random(200, 300));
    748. 

  748. 	moveMouse(random(70, 400), random(40, 335));
    749. 

  749. 	wait(random(4900, 6200));
    750. 

  750. 	atInterface(741, 9);
    751. 

  751. 	wait(random(50, 500));
    752. 

  752.     }
    753. 

  753. 

  754.     public void clickMainMenu() {
    755. 

  755. 	do {
    756. 

  756. 	    moveMouse(random(296, 472), random(410, 422), 5, 5);
    757. 

  757. 	} while (!mouseInArea(472, 422, 296, 410));
    758. 

  758. 	clickMouse(true);
    759. 

  759.     }
    760. 

  760. 

  761.     public int Login() {
    762. 

  762. 	while (!isLoggedIn()) {
    763. 

  763. 	    if (isLoggedIn()) {
    764. 

  764. 		while (RSInterface.getChildInterface(
    765. 

  765. 			WelcomeScreen.WELCOME_SCREEN_ID,
    766. 

  766. 			WelcomeScreen.WELCOME_SCREEN_BUTTON_PLAY)
    767. 

  767. 			.getAbsoluteY() < 2) {
    768. 

  768. 		    wait(random(1500, 2500));
    769. 

  769. 		}
    770. 

  770. 		return -1;
    771. 

  771. 	    }
    772. 

  772. 	    if (failSafeCount > 19) {
    773. 

  773. 		log("Can't log in... Stopping script.");
    774. 

  774. 		stopScript();
    775. 

  775. 		return -1;
    776. 

  776. 	    }
    777. 

  777. 	    if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    778. 

  778. 		    .getText().contains("update")) {
    779. 

  779. 		log("There was a update. Stopping script.");
    780. 

  780. 		stopScript();
    781. 

  781. 		return -1;
    782. 

  782. 	    }
    783. 

  783. 	    if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    784. 

  784. 		    .getText().contains("disable")) {
    785. 

  785. 		log("Can't log in... stopping script");
    786. 

  786. 		stopScript();
    787. 

  787. 		return -1;
    788. 

  788. 	    }
    789. 

  789. 	    if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    790. 

  790. 		    .getText().contains("members")) {
    791. 

  791. 		member2 = false;
    792. 

  792. 		clickMainMenu();
    793. 

  793. 		worldHop();
    794. 

  794. 	    }
    795. 

  795. 	    if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    796. 

  796. 		    .getText().contains("incorrect")) {
    797. 

  797. 		log("Can't log in... stopping script.");
    798. 

  798. 		stopScript();
    799. 

  799. 		return -1;
    800. 

  800. 	    }
    801. 

  801. 	    if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    802. 

  802. 		    .getText().contains("invalid")) {
    803. 

  803. 		failSafeCount++;
    804. 

  804. 	    }
    805. 

  805. 	    if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    806. 

  806. 		    .getText().contains("full")) {
    807. 

  807. 		clickMainMenu();
    808. 

  808. 		worldHop();
    809. 

  809. 	    }
    810. 

  810. 	    if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    811. 

  811. 		    .getText().contains("Error connecting")) {
    812. 

  812. 		boolean connected = false;
    813. 

  813. 		log("Internet connection lost.. waiting for connection");
    814. 

  814. 		while (!connected) {
    815. 

  815. 		    try {
    816. 

  816. 			final URL rs = new URL(
    817. 

  817. 				"http://www.runescape.com");
    818. 

  818. 			final URLConnection connection = rs
    819. 

  819. 				.openConnection();
    820. 

  820. 			final BufferedReader reader = new BufferedReader(
    821. 

  821. 				new InputStreamReader(connection
    822. 

  822. 					.getInputStream()));
    823. 

  823. 			String contents = "";
    824. 

  824. 			String s = "";
    825. 

  825. 			while ((s = reader.readLine()) != null) {
    826. 

  826. 			    contents = contents.concat(s);
    827. 

  827. 			}
    828. 

  828. 			if (contents != null) {
    829. 

  829. 			    log("Connection restored!");
    830. 

  830. 			    connected = true;
    831. 

  831. 			}
    832. 

  832. 		    } catch (final Exception e) {
    833. 

  833. 			log("Unable to connect, retrying connection");
    834. 

  834. 			wait(random(5000, 10000));
    835. 

  835. 		    }
    836. 

  836. 		}
    837. 

  837. 	    }
    838. 

  838. 	    if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    839. 

  839. 		    .getText().contains("world")) {
    840. 

  840. 		while (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    841. 

  841. 			.getText().contains("world")) {
    842. 

  842. 		    wait(random(200, 500));
    843. 

  843. 		}
    844. 

  844. 	    }
    845. 

  845. 	    if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    846. 

  846. 		    .getText().contains("Performing login")) {
    847. 

  847. 		wait(random(1500, 2500));
    848. 

  848. 		if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    849. 

  849. 			.getText().contains("Performing login")) {
    850. 

  850. 		    done = true;
    851. 

  851. 		    return -1;
    852. 

  852. 		} else {
    853. 

  853. 		    wait(random(100, 200));
    854. 

  854. 		}
    855. 

  855. 	    }
    856. 

  856. 	    if (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    857. 

  857. 		    .getText().contains("transferred")) {
    858. 

  858. 		while (RSInterface.getInterface(744).getChild(TEXT_INTERFACE)
    859. 

  859. 			.getText().contains("transferred")) {
    860. 

  860. 		    wait(random(200, 500));
    861. 

  861. 		}
    862. 

  862. 	    }
    863. 

  863. 	    int typingPropType = 0;
    864. 

  864. 	    if (isLoginScreen()) {
    865. 

  865. 		int propTrys = 0;
    866. 

  866. 		while (true) {
    867. 

  867. 		    propTrys++;
    868. 

  868. 		    if (RSInterface.getInterface(744).getChild(
    869. 

  869. 			    USERNAME_INTERFACE).getText().endsWith("|")) {
    870. 

  870. 			typingPropType = 1;
    871. 

  871. 			break;
    872. 

  872. 		    }
    873. 

  873. 		    if (RSInterface.getInterface(744).getChild(
    874. 

  874. 			    PASSWORD_INTERFACE).getText().endsWith("|")) {
    875. 

  875. 			typingPropType = 2;
    876. 

  876. 			break;
    877. 

  877. 		    }
    878. 

  878. 		    if (propTrys == 50) {
    879. 

  879. 			break;
    880. 

  880. 		    }
    881. 

  881. 		    wait(random(10, 20));
    882. 

  882. 		}
    883. 

  883. 		if (typingPropType == 0) {
    884. 

  884. 		    moveMouse(299, 180, 166, 18);
    885. 

  885. 		    clickMouse(true);
    886. 

  886. 		}
    887. 

  887. 		if (typingPropType == 1) {
    888. 

  888. 		    sendUserProp(
    889. 

  889. 			    accountName.replaceAll("_", " ").toLowerCase(),
    890. 

  890. 			    USERNAME_INTERFACE);
    891. 

  891. 		}
    892. 

  892. 		if (typingPropType == 2) {
    893. 

  893. 		    sendUserProp(AccountManager.getPassword(accountName),
    894. 

  894. 			    PASSWORD_INTERFACE);
    895. 

  895. 		}
    896. 

  896. 	    }
    897. 

  897. 	    return random(250, 500);
    898. 

  898. 	}
    899. 

  899. 	return random(250, 500);
    900. 

  900.     }
    901. 

  901. 

  902.     private void sendUserProp(final String data, final int type) {
    903. 

  903. 	String boxText = RSInterface.getInterface(744).getChild(type).getText();
    904. 

  904. 	if (boxText.endsWith("|")) {
    905. 

  905. 	    boxText = boxText.substring(0, boxText.length() - 1);
    906. 

  906. 	}
    907. 

  907. 	final int boxTextLength = boxText.length();
    908. 

  908. 	if (boxTextLength == data.length()) {
    909. 

  909. 	    sendText("", true);
    910. 

  910. 	    return;
    911. 

  911. 	}
    912. 

  912. 	if (boxTextLength > 0 && boxTextLength != data.length()) {
    913. 

  913. 	    for (int i = 0; i <= boxTextLength; i++) {
    914. 

  914. 		sendText("\b", false);
    915. 

  915. 		wait(random(5, 10));
    916. 

  916. 	    }
    917. 

  917. 	}
    918. 

  918. 	sendText(data, false);
    919. 

  919. 	sendUserProp(data, type);
    920. 

  920.     }
    921. 

  921. 

  922.     // GEM DROPPING METHOD
    923. 

  923.     public void dropGems() {
    924. 

  924. 	if (diamond) {
    925. 

  925. 	    if (getInventoryCount(1617) > 0) {
    926. 

  926. 		atInventoryItem(1623, "Drop");
    927. 

  927. 	    }
    928. 

  928. 	}
    929. 

  929. 	if (ruby) {
    930. 

  930. 	    if (getInventoryCount(1619) > 0) {
    931. 

  931. 		atInventoryItem(1621, "Drop");
    932. 

  932. 	    }
    933. 

  933. 	}
    934. 

  934. 	if (emerald) {
    935. 

  935. 	    if (getInventoryCount(1621) > 0) {
    936. 

  936. 		atInventoryItem(1619, "Drop");
    937. 

  937. 	    }
    938. 

  938. 	}
    939. 

  939. 	if (sapphire) {
    940. 

  940. 	    if (getInventoryCount(1623) > 0) {
    941. 

  941. 		atInventoryItem(1617, "Drop");
    942. 

  942. 	    }
    943. 

  943. 	}
    944. 

  944.     }
    945. 

  945. 

  946.     public int getNumberOfAlchableItems() {
    947. 

  947. 	int i = 0;
    948. 

  948. 	if (alchG) {
    949. 

  949. 	    i = getInventoryCount(gems) + i;
    950. 

  950. 	}
    951. 

  951. 	if (alchB) {
    952. 

  952. 	    i = getInventoryCount(bars) + i;
    953. 

  953. 	}
    954. 

  954. 	if (alchGO) {
    955. 

  955. 	    if (mith) {
    956. 

  956. 		i = getInventoryCount(447) + i;
    957. 

  957. 	    } else if (addy) {
    958. 

  958. 		i = getInventoryCount(449) + i;
    959. 

  959. 	    } else {
    960. 

  960. 		i = getInventoryCount(449) + i + getInventoryCount(447);
    961. 

  961. 	    }
    962. 

  962. 	}
    963. 

  963. 	if (alchSO) {
    964. 

  964. 	    i = getInventoryCount(453) + i;
    965. 

  965. 	}
    966. 

  966. 	return i;
    967. 

  967.     }
    968. 

  968. 

  969.     // HIGH ALCH METHOD
    970. 

  970.     public int Highalch() {
    971. 

  971. 	int abx = 0;
    972. 

  972. 	int o = 0;
    973. 

  973. 	while (getNumberOfAlchableItems() >= 1) {
    974. 

  974. 	    if (ableToCast()) {
    975. 

  975. 		return -1;
    976. 

  976. 	    }
    977. 

  977. 	    if (getMyPlayer().getAnimation() == 624) {
    978. 

  978. 		return -1;
    979. 

  979. 	    }
    980. 

  980. 	    if (!inventoryContains(561)) {
    981. 

  981. 		log("Unable to complete task... shutting down");
    982. 

  982. 		stopScript();
    983. 

  983. 	    }
    984. 

  984. 	    castSpell(SPELL_HIGH_LEVEL_ALCHEMY);
    985. 

  985. 	    while (getCurrentTab() != TAB_INVENTORY && o < 6) {
    986. 

  986. 		wait(random(250, 750));
    987. 

  987. 		o++;
    988. 

  988. 	    }
    989. 

  989. 	    o = 0;
    990. 

  990. 	    if (wieldStaff == 1) {
    991. 

  991. 		if (!inventoryContains(1387)) {
    992. 

  992. 		    if (equipmentContains(1387)) {
    993. 

  993. 			continue;
    994. 

  994. 		    }
    995. 

  995. 		    log("Unable to complete task... shutting down");
    996. 

  996. 		    stopScript();
    997. 

  997. 		} else {
    998. 

  998. 		    atInventoryItem(1387, "ield");
    999. 

  999. 		}
    1000. 

  1000. 	    }
    1001. 

  1001. 	    if (getNumberOfAlchableItems() == 0) {
    1002. 

  1002. 		break;
    1003. 

  1003. 	    } else {
    1004. 

  1004. 		if (alchSO) {
    1005. 

  1005. 		    if (getInventoryCount(453) > 0) {
    1006. 

  1006. 			atInventoryItem(453, "Cast");
    1007. 

  1007. 			while (getMyPlayer().getAnimation() == 9633) {
    1008. 

  1008. 			    wait(random(20, 30));
    1009. 

  1009. 			}
    1010. 

  1010. 			while (getCurrentTab() != TAB_MAGIC) {
    1011. 

  1011. 			    wait(random(20, 30));
    1012. 

  1012. 			}
    1013. 

  1013. 			continue;
    1014. 

  1014. 		    }
    1015. 

  1015. 		}
    1016. 

  1016. 		if (alchGO) {
    1017. 

  1017. 		    if (getInventoryCount(447) > 0) {
    1018. 

  1018. 			atInventoryItem(447, "Cast");
    1019. 

  1019. 			while (getMyPlayer().getAnimation() == 9633) {
    1020. 

  1020. 			    wait(random(20, 30));
    1021. 

  1021. 			}
    1022. 

  1022. 			while (getCurrentTab() != TAB_MAGIC) {
    1023. 

  1023. 			    wait(random(20, 30));
    1024. 

  1024. 			}
    1025. 

  1025. 			continue;
    1026. 

  1026. 		    }
    1027. 

  1027. 		}
    1028. 

  1028. 		if (alchGO) {
    1029. 

  1029. 		    if (getInventoryCount(449) > 0) {
    1030. 

  1030. 			atInventoryItem(449, "Cast");
    1031. 

  1031. 			while (getMyPlayer().getAnimation() == 9633) {
    1032. 

  1032. 			    wait(random(20, 30));
    1033. 

  1033. 			}
    1034. 

  1034. 			while (getCurrentTab() != TAB_MAGIC) {
    1035. 

  1035. 			    wait(random(20, 30));
    1036. 

  1036. 			}
    1037. 

  1037. 			continue;
    1038. 

  1038. 		    }
    1039. 

  1039. 		}
    1040. 

  1040. 		if (alchG) {
    1041. 

  1041. 		    if (getInventoryCount(1617) > 0) {
    1042. 

  1042. 			atInventoryItem(1617, "Cast");
    1043. 

  1043. 			while (getMyPlayer().getAnimation() == 9633) {
    1044. 

  1044. 			    wait(random(20, 30));
    1045. 

  1045. 			}
    1046. 

  1046. 			while (getCurrentTab() != TAB_MAGIC) {
    1047. 

  1047. 			    wait(random(20, 30));
    1048. 

  1048. 			}
    1049. 

  1049. 			continue;
    1050. 

  1050. 		    }
    1051. 

  1051. 		    if (getInventoryCount(1619) > 0) {
    1052. 

  1052. 			atInventoryItem(1619, "Cast");
    1053. 

  1053. 			while (getMyPlayer().getAnimation() == 9633) {
    1054. 

  1054. 			    wait(random(20, 30));
    1055. 

  1055. 			}
    1056. 

  1056. 			while (getCurrentTab() != TAB_MAGIC) {
    1057. 

  1057. 			    wait(random(20, 30));
    1058. 

  1058. 			}
    1059. 

  1059. 			continue;
    1060. 

  1060. 		    }
    1061. 

  1061. 		    if (getInventoryCount(1621) > 0) {
    1062. 

  1062. 			atInventoryItem(1621, "Cast");
    1063. 

  1063. 			while (getMyPlayer().getAnimation() == 9633) {
    1064. 

  1064. 			    wait(random(20, 30));
    1065. 

  1065. 			}
    1066. 

  1066. 			while (getCurrentTab() != TAB_MAGIC) {
    1067. 

  1067. 			    wait(random(20, 30));
    1068. 

  1068. 			}
    1069. 

  1069. 			continue;
    1070. 

  1070. 		    }
    1071. 

  1071. 		    if (getInventoryCount(1623) > 0) {
    1072. 

  1072. 			atInventoryItem(1623, "Cast");
    1073. 

  1073. 			while (getMyPlayer().getAnimation() == 9633) {
    1074. 

  1074. 			    wait(random(20, 30));
    1075. 

  1075. 			}
    1076. 

  1076. 			while (getCurrentTab() != TAB_MAGIC) {
    1077. 

  1077. 			    wait(random(20, 30));
    1078. 

  1078. 			}
    1079. 

  1079. 			continue;
    1080. 

  1080. 		    }
    1081. 

  1081. 		}
    1082. 

  1082. 		if (alchB) {
    1083. 

  1083. 		    if (getInventoryCount(2359) > 0) {
    1084. 

  1084. 			atInventoryItem(2359, "Cast");
    1085. 

  1085. 			while (getMyPlayer().getAnimation() == 9633) {
    1086. 

  1086. 			    wait(random(20, 30));
    1087. 

  1087. 			}
    1088. 

  1088. 			while (getCurrentTab() != TAB_MAGIC) {
    1089. 

  1089. 			    wait(random(20, 30));
    1090. 

  1090. 			}
    1091. 

  1091. 			continue;
    1092. 

  1092. 		    }
    1093. 

  1093. 		    if (getInventoryCount(2361) > 0) {
    1094. 

  1094. 			atInventoryItem(0, "Cast");
    1095. 

  1095. 			while (getMyPlayer().getAnimation() == 9633) {
    1096. 

  1096. 			    wait(random(20, 30));
    1097. 

  1097. 			}
    1098. 

  1098. 			while (getCurrentTab() != TAB_MAGIC) {
    1099. 

  1099. 			    wait(random(20, 30));
    1100. 

  1100. 			}
    1101. 

  1101. 			continue;
    1102. 

  1102. 		    }
    1103. 

  1103. 		}
    1104. 

  1104. 	    }
    1105. 

  1105. 	}
    1106. 

  1106. 	if (abx >= 11) {
    1107. 

  1107. 	    log("Unable to complete task... shutting down");
    1108. 

  1108. 	    stopScript();
    1109. 

  1109. 	}
    1110. 

  1110. 	return random(500, 1000);
    1111. 

  1111.     }
    1112. 

  1112. 

  1113.     // SCROLLING METHOD
    1114. 

  1114.     public void scroll() {
    1115. 

  1115. 	try {
    1116. 

  1116. 	    Point point = null;
    1117. 

  1117. 	    final RSInterfaceComponent[] click = RSInterface.getInterface(744)
    1118. 

  1118. 		    .getChild(178).getComponents();
    1119. 

  1119. 	    point = new Point(click[0].getPoint());
    1120. 

  1120. 	    moveMouse(point, 0, 100);
    1121. 

  1121. 	    wait(random(200, 500));
    1122. 

  1122. 	    clickMouse(true);
    1123. 

  1123. 	} catch (final Exception e) {
    1124. 

  1124. 	    return;
    1125. 

  1125. 	}
    1126. 

  1126.     }
    1127. 

  1127. 

  1128.     // REORDER WORLD LIST - TYPE
    1129. 

  1129.     public void reorderTypeList() {
    1130. 

  1130. 	final Point point = new Point(RSInterface.getInterface(744).getChild(
    1131. 

  1131. 		184).getAbsoluteX(), RSInterface.getInterface(744)
    1132. 

  1132. 		.getChild(184).getAbsoluteY());
    1133. 

  1133. 	moveMouse(point, 1, 1);
    1134. 

  1134. 	wait(random(100, 300));
    1135. 

  1135. 	clickMouse(true);
    1136. 

  1136.     }
    1137. 

  1137. 

  1138.     public void reorderTypeListMember() {
    1139. 

  1139. 	final Point point = new Point(RSInterface.getInterface(744).getChild(
    1140. 

  1140. 		184).getAbsoluteX(), RSInterface.getInterface(744)
    1141. 

  1141. 		.getChild(183).getAbsoluteY());
    1142. 

  1142. 	moveMouse(point, 1, 1);
    1143. 

  1143. 	wait(random(100, 300));
    1144. 

  1144. 	clickMouse(true);
    1145. 

  1145.     }
    1146. 

  1146. 

  1147.     public int getNumberOfItems() {
    1148. 

  1148. 	int item = 0;
    1149. 

  1149. 	if (mithBar) {
    1150. 

  1150. 	    item = item + getInventoryCount(447);
    1151. 

  1151. 	}
    1152. 

  1152. 	if (addyBar) {
    1153. 

  1153. 	    item = item + getInventoryCount(449);
    1154. 

  1154. 	}
    1155. 

  1155. 	return item;
    1156. 

  1156.     }
    1157. 

  1157. 

  1158.     public int getNumberOfCoal() {
    1159. 

  1159. 	int coal = 0;
    1160. 

  1160. 	if (mithBar && getInventoryCount(447) > 0) {
    1161. 

  1161. 	    coal = 4;
    1162. 

  1162. 	}
    1163. 

  1163. 	if (addyBar && getInventoryCount(449) > 0) {
    1164. 

  1164. 	    coal = 7;
    1165. 

  1165. 	}
    1166. 

  1166. 	return coal;
    1167. 

  1167.     }
    1168. 

  1168. 

  1169.     // SUPER HEATING METHOD
    1170. 

  1170. 

  1171.     public int castSuperHeat() {
    1172. 

  1172. 	int abx = 0;
    1173. 

  1173. 	int o = 0;
    1174. 

  1174. 	int item = 0;
    1175. 

  1175. 

  1176. 	while (getInventoryCount(453) >= getNumberOfCoal()
    1177. 

  1177. 		&& getNumberOfItems() >= 1 && abx < 10) {
    1178. 

  1178. 	    while (getMyPlayer().getAnimation() == 624) {
    1179. 

  1179. 		wait(random(100, 500));
    1180. 

  1180. 	    }
    1181. 

  1181. 	    if (!inventoryContains(561)) {
    1182. 

  1182. 		log("You are out of nature runes...Stopping script...");
    1183. 

  1183. 		logout();
    1184. 

  1184. 		stopScript();
    1185. 

  1185. 	    }
    1186. 

  1186. 	    status = "Superheating";
    1187. 

  1187. 	    castSpell(SPELL_SUPERHEAT_ITEM);
    1188. 

  1188. 	    while (getCurrentTab() != TAB_INVENTORY && o < 6) {
    1189. 

  1189. 		wait(random(250, 750));
    1190. 

  1190. 		o++;
    1191. 

  1191. 	    }
    1192. 

  1192. 	    o = 0;
    1193. 

  1193. 	    if (getCurrentTab() != TAB_INVENTORY) {
    1194. 

  1194. 		openTab(TAB_INVENTORY);
    1195. 

  1195. 	    }
    1196. 

  1196. 	    if (mithBar) {
    1197. 

  1197. 		if (getInventoryCount(447) >= 1 && getInventoryCount(453) >= 4) {
    1198. 

  1198. 		    item = 447;
    1199. 

  1199. 		}
    1200. 

  1200. 	    }
    1201. 

  1201. 	    if (addyBar) {
    1202. 

  1202. 		if (getInventoryCount(449) >= 1 && getInventoryCount(453) >= 7) {
    1203. 

  1203. 		    item = 449;
    1204. 

  1204. 		}
    1205. 

  1205. 	    }
    1206. 

  1206. 	    if (!atInventoryItem(item, "Cast")) {
    1207. 

  1207. 		abx++;
    1208. 

  1208. 	    }
    1209. 

  1209. 	    wait(random(2000, 2500));
    1210. 

  1210. 	    if (superheatError == 1) {
    1211. 

  1211. 		log("You do not have the smithing lvl required...Stopping script...");
    1212. 

  1212. 		logout();
    1213. 

  1213. 		stopScript();
    1214. 

  1214. 	    }
    1215. 

  1215. 	    if (wieldStaff == 1) {
    1216. 

  1216. 		if (!inventoryContains(1387)) {
    1217. 

  1217. 		    if (equipmentContains(1387)) {
    1218. 

  1218. 			continue;
    1219. 

  1219. 		    }
    1220. 

  1220. 		    log("You do not have a fire staff...Stopping script...");
    1221. 

  1221. 		    logout();
    1222. 

  1222. 		    stopScript();
    1223. 

  1223. 		} else {
    1224. 

  1224. 		    atInventoryItem(1387, "ield");
    1225. 

  1225. 		}
    1226. 

  1226. 	    }
    1227. 

  1227. 	}
    1228. 

  1228. 	if (abx >= 11) {
    1229. 

  1229. 	    log("Unable to cast superheat...Stopping script...");
    1230. 

  1230. 	    logout();
    1231. 

  1231. 	    stopScript();
    1232. 

  1232. 	}
    1233. 

  1233. 	return random(500, 1000);
    1234. 

  1234.     }
    1235. 

  1235. 

  1236.     // AREA METHODS
    1237. 

  1237.     public boolean atBank() {
    1238. 

  1238. 	if (alkharid) {
    1239. 

  1239. 	    if (isInArea(3271, 3162, 3269, 3173)) {
    1240. 

  1240. 		return true;
    1241. 

  1241. 	    }
    1242. 

  1242. 	} else if (draynor) {
    1243. 

  1243. 	    if (isInArea(3095, 3240, 3092, 3246)) {
    1244. 

  1244. 		return true;
    1245. 

  1245. 	    }
    1246. 

  1246. 	} else if (falador) {
    1247. 

  1247. 	    if (isInArea(3018, 3355, 3009, 3358)) {
    1248. 

  1248. 		return true;
    1249. 

  1249. 	    }
    1250. 

  1250. 	}
    1251. 

  1251. 	return false;
    1252. 

  1252.     }
    1253. 

  1253. 

  1254.     public boolean atMine() {
    1255. 

  1255. 	if (alkharid) {
    1256. 

  1256. 	    if (isInArea(3308, 3283, 3293, 3319)) {
    1257. 

  1257. 		return true;
    1258. 

  1258. 	    }
    1259. 

  1259. 	} else if (draynor) {
    1260. 

  1260. 	    if (isInArea(3150, 3144, 3143, 3154)) {
    1261. 

  1261. 		return true;
    1262. 

  1262. 	    }
    1263. 

  1263. 	} else if (falador) {
    1264. 

  1264. 	    if (isInArea(3046, 9759, 3033, 9780)) {
    1265. 

  1265. 		return true;
    1266. 

  1266. 	    }
    1267. 

  1267. 	}
    1268. 

  1268. 	return false;
    1269. 

  1269.     }
    1270. 

  1270. 

  1271.     public boolean isInArea(final int maxX, final int minY, final int minX,
    1272. 

  1272. 	    final int maxY) {
    1273. 

  1273. 	final int x = getMyPlayer().getLocation().getX();
    1274. 

  1274. 	final int y = getMyPlayer().getLocation().getY();
    1275. 

  1275. 	if (x >= minX && x <= maxX && y >= minY && y <= maxY) {
    1276. 

  1276. 	    return true;
    1277. 

  1277. 	}
    1278. 

  1278. 	return false;
    1279. 

  1279.     }
    1280. 

  1280. 

  1281.     public boolean inArea(final Point p, final int x, final int y, final int w,
    1282. 

  1282. 	    final int h) {
    1283. 

  1283. 	if (p.x > x && p.x < x + w && p.y > y && p.y < y + h) {
    1284. 

  1284. 	    return true;
    1285. 

  1285. 	} else {
    1286. 

  1286. 	    return false;
    1287. 

  1287. 	}
    1288. 

  1288.     }
    1289. 

  1289. 

  1290.     public boolean mouseInArea(int x, int y, int xx, int yy) {
    1291. 

  1291. 	int x3 = input.getX();
    1292. 

  1292. 	int y3 = input.getY();
    1293. 

  1293. 

  1294. 	if (x3 < x && x3 > xx && y3 < y && y3 > yy) {
    1295. 

  1295. 	    return true;
    1296. 

  1296. 	} else {
    1297. 

  1297. 	    return false;
    1298. 

  1298. 	}
    1299. 

  1299.     }
    1300. 

  1300. 

  1301.     // WALKING METHODS
    1302. 

  1302.     public boolean isResting() {
    1303. 

  1303. 	if (getMyPlayer().getAnimation() == 12108
    1304. 

  1304. 		|| getMyPlayer().getAnimation() == 2033
    1305. 

  1305. 		|| getMyPlayer().getAnimation() == 2716
    1306. 

  1306. 		|| getMyPlayer().getAnimation() == 11786
    1307. 

  1307. 		|| getMyPlayer().getAnimation() == 5713) {
    1308. 

  1308. 	    return true;
    1309. 

  1309. 	}
    1310. 

  1310. 	return false;
    1311. 

  1311.     }
    1312. 

  1312. 

  1313.     public void runCheck() {
    1314. 

  1314. 	int tries = 0;
    1315. 

  1315. 	int replenishes = 0;
    1316. 

  1316. 	int currentEnergy = 0;
    1317. 

  1317. 	boolean rest = true;
    1318. 

  1318. 	if (getEnergy() > 21 + random(1, 29) || getEnergy() >= 51) {
    1319. 

  1319. 	    setRun(true);
    1320. 

  1320. 	}
    1321. 

  1321. 	if (getEnergy() <= 1 && !atMine() && !atBank() && rest
    1322. 

  1322. 		&& settings.useRest) {
    1323. 

  1323. 	    if (ring && replenishes <= 3) {
    1324. 

  1324. 		do {
    1325. 

  1325. 		    openTab(TAB_EQUIPMENT);
    1326. 

  1326. 		    wait(random(200, 300));
    1327. 

  1327. 		    tries++;
    1328. 

  1328. 		} while (getCurrentTab() != TAB_EQUIPMENT && tries < 10);
    1329. 

  1329. 		tries = 0;
    1330. 

  1330. 		currentEnergy = getEnergy();
    1331. 

  1331. 		atEquippedItem(13562, "un-replenish");
    1332. 

  1332. 		wait(random(250, 500));
    1333. 

  1333. 		if (getEnergy() > currentEnergy) {
    1334. 

  1334. 		    replenishes++;
    1335. 

  1335. 		} else {
    1336. 

  1336. 		    replenishes = 3;
    1337. 

  1337. 		}
    1338. 

  1338. 	    } else {
    1339. 

  1339. 		if (random(-10, 10) > 0) {
    1340. 

  1340. 		    rest(random(40 + random(5, 20), 80 + random(5, 19)));
    1341. 

  1341. 		}
    1342. 

  1342. 	    }
    1343. 

  1343. 	    rest = false;
    1344. 

  1344. 	}
    1345. 

  1345. 	if (getEnergy() > 1) {
    1346. 

  1346. 	    rest = true;
    1347. 

  1347. 	}
    1348. 

  1348. 	if (getEnergy() == 100 && isResting()) {
    1349. 

  1349. 	    walk();
    1350. 

  1350. 	}
    1351. 

  1351.     }
    1352. 

  1352. 

  1353.     public void walk() {
    1354. 

  1354. 	atTile(new RSTile(getMyPlayer().getLocation().getX() + random(-1, 1),
    1355. 

  1355. 		getMyPlayer().getLocation().getY() + random(-1, 1)), "alk Here");
    1356. 

  1356.     }
    1357. 

  1357. 

  1358.     public boolean nearTile(final RSTile tile) {
    1359. 

  1359. 	wait(random(700, 1000));
    1360. 

  1360. 	while (distanceTo(tile) >= 3 && getMyPlayer().isMoving()) {
    1361. 

  1361. 	    return false;
    1362. 

  1362. 	}
    1363. 

  1363. 	return true;
    1364. 

  1364.     }
    1365. 

  1365. 

  1366.     public boolean nearTile2(final RSTile tile) {
    1367. 

  1367. 	wait(random(700, 1000));
    1368. 

  1368. 	while (distanceTo(tile) >= 1 && getMyPlayer().isMoving()) {
    1369. 

  1369. 	    return false;
    1370. 

  1370. 	}
    1371. 

  1371. 	return true;
    1372. 

  1372.     }
    1373. 

  1373. 

  1374.     public RSTile getNextTile(final RSTile[] path, final int maxDist) {
    1375. 

  1375. 	for (int i = path.length - 1; i >= 0; i--) {
    1376. 

  1376. 	    if (distanceTo(path[i]) <= maxDist) {
    1377. 

  1377. 		return path[i];
    1378. 

  1378. 	    }
    1379. 

  1379. 	}
    1380. 

  1380. 	return null;
    1381. 

  1381.     }
    1382. 

  1382. 

  1383.     public boolean walkPath(final RSTile[] path, final int maxDist,
    1384. 

  1384. 	    final int randomness) {
    1385. 

  1385. 	if (distanceTo(path[path.length - 1]) <= 4) {
    1386. 

  1386. 	    return true;
    1387. 

  1387. 	} else {
    1388. 

  1388. 	    final RSTile theTile = getNextTile(path, maxDist);
    1389. 

  1389. 	    if (theTile != null) {
    1390. 

  1390. 		walkTile(theTile, randomness);
    1391. 

  1391. 	    }
    1392. 

  1392. 	    return false;
    1393. 

  1393. 	}
    1394. 

  1394.     }
    1395. 

  1395. 

  1396.     public boolean walkPath(final RSTile[] path) {
    1397. 

  1397. 	return walkPath(path, 15, 1);
    1398. 

  1398.     }
    1399. 

  1399. 

  1400.     public boolean WalkTileMM(final RSTile t, final int x, final int y) {
    1401. 

  1401. 	final Point p = tileToMinimap(t);
    1402. 

  1402. 	if (p.x == -1 || p.y == -1) {
    1403. 

  1403. 	    return WalkTileMM(getClosestTileOnMap(t), x, y);
    1404. 

  1404. 	}
    1405. 

  1405. 	clickMouse(p, x, y, true);
    1406. 

  1406. 	return true;
    1407. 

  1407.     }
    1408. 

  1408. 

  1409.     public boolean WalkTileMM(final RSTile t) {
    1410. 

  1410. 	return WalkTileMM(t, 2, 2);
    1411. 

  1411.     }
    1412. 

  1412. 

  1413.     public boolean walkTile(final RSTile theTile) {
    1414. 

  1414. 	return walkTile(theTile, 1);
    1415. 

  1415.     }
    1416. 

  1416. 

  1417.     public boolean walkTile(final RSTile theTile, final int randomness) {
    1418. 

  1418. 	if (theTile == null) {
    1419. 

  1419. 	    return false;
    1420. 

  1420. 	}
    1421. 

  1421. 	if (distanceTo(theTile) <= 17) {
    1422. 

  1422. 	    RSTile newTile;
    1423. 

  1423. 	    if (randomness == 0) {
    1424. 

  1424. 		newTile = new RSTile(theTile.getX(), theTile.getY());
    1425. 

  1425. 	    } else {
    1426. 

  1426. 		newTile = new RSTile(theTile.getX()
    1427. 

  1427. 			+ random(-randomness, randomness + 1), theTile.getY()
    1428. 

  1428. 			+ random(-randomness, randomness + 1));
    1429. 

  1429. 	    }
    1430. 

  1430. 

  1431. 	    if (random(0, 30) == 0) {
    1432. 

  1432. 		turnToTile(newTile, 15);
    1433. 

  1433. 	    }
    1434. 

  1434. 

  1435. 	    if (tileOnScreen(newTile) && random(0, 10) == 0) {
    1436. 

  1436. 		if (!atTile(newTile, "Walk")) {
    1437. 

  1437. 		    if (!WalkTileMM(newTile)) {
    1438. 

  1438. 			return false;
    1439. 

  1439. 		    } else {
    1440. 

  1440. 			return true;
    1441. 

  1441. 		    }
    1442. 

  1442. 		} else {
    1443. 

  1443. 		    return true;
    1444. 

  1444. 		}
    1445. 

  1445. 	    } else {
    1446. 

  1446. 		if (!WalkTileMM(newTile)) {
    1447. 

  1447. 		    return false;
    1448. 

  1448. 		} else {
    1449. 

  1449. 		    return true;
    1450. 

  1450. 		}
    1451. 

  1451. 	    }
    1452. 

  1452. 	} else {
    1453. 

  1453. 	    return false;
    1454. 

  1454. 	}
    1455. 

  1455.     }
    1456. 

  1456. 

  1457.     public boolean walkToBank() {
    1458. 

  1458. 	int tries = 0;
    1459. 

  1459. 	boolean jumped = false;
    1460. 

  1460. 	if (alkharid) {
    1461. 

  1461. 	    walkPath(fixPath(generateProperPath(new RSTile(3270, 3166))));
    1462. 

  1462. 	} else if (draynor) {
    1463. 

  1463. 	    if (ring) {
    1464. 

  1464. 		do {
    1465. 

  1465. 		    openTab(TAB_EQUIPMENT);
    1466. 

  1466. 		    wait(random(200, 300));
    1467. 

  1467. 		    tries++;
    1468. 

  1468. 		} while (getCurrentTab() != TAB_EQUIPMENT && tries < 10);
    1469. 

  1469. 		tries = 0;
    1470. 

  1470. 		RSTile currentLocation = getMyPlayer().getLocation();
    1471. 

  1471. 		atEquippedItem(13562, "abbage-port");
    1472. 

  1472. 		wait(random(2500, 5000));
    1473. 

  1473. 		while (getMyPlayer().getLocation() == currentLocation
    1474. 

  1474. 			&& tries <= 10) {
    1475. 

  1475. 		    wait(random(300, 500));
    1476. 

  1476. 		    tries++;
    1477. 

  1477. 		}
    1478. 

  1478. 		tries = 0;
    1479. 

  1479. 		while (distanceTo(new RSTile(3063, 3283)) > 4) {
    1480. 

  1480. 		    walkPath(cabbageToStile);
    1481. 

  1481. 		    wait(random(500, 600));
    1482. 

  1482. 		}
    1483. 

  1483. 		while (!jumped) {
    1484. 

  1484. 		    jumpStile(new RSTile(3063, 3283), new RSTile(3063, 3282));
    1485. 

  1485. 		    while (tries <= 20) {
    1486. 

  1486. 			wait(random(200, 300));
    1487. 

  1487. 			tries++;
    1488. 

  1488. 			if (getMyPlayer().getLocation().getX() == 3063
    1489. 

  1489. 				&& getMyPlayer().getLocation().getY() == 3282) {
    1490. 

  1490. 			    jumped = true;
    1491. 

  1491. 			    break;
    1492. 

  1492. 			}
    1493. 

  1493. 		    }
    1494. 

  1494. 		    tries = 0;
    1495. 

  1495. 		}
    1496. 

  1496. 		while (!atBank()) {
    1497. 

  1497. 		    walkPath(stileToBank);
    1498. 

  1498. 		    wait(random(500, 1000));
    1499. 

  1499. 		}
    1500. 

  1500. 		jumped = false;
    1501. 

  1501. 	    } else {
    1502. 

  1502. 		walkPath(draynorToBank);
    1503. 

  1503. 	    }
    1504. 

  1504. 	} else if (falador) {
    1505. 

  1505. 	    if (atBank()) {
    1506. 

  1506. 		return false;
    1507. 

  1507. 	    } else if (isInArea(3065, 3359, 3005, 3374)) {
    1508. 

  1508. 		walkPath(doorToBank);
    1509. 

  1509. 	    } else if (isInArea(3062, 3375, 3058, 3381)) {
    1510. 

  1510. 		try {
    1511. 

  1511. 		    if (!isDoorOpen(new RSTile(3061, 3375), 11715)) {
    1512. 

  1512. 			openDoor(new RSTile(3061, 3374), new RSTile(3061, 3375));
    1513. 

  1513. 		    } else {
    1514. 

  1514. 			walkPath(doorToBank);
    1515. 

  1515. 		    }
    1516. 

  1516. 		} catch (Exception e) {
    1517. 

  1517. 

  1518. 		}
    1519. 

  1519. 	    } else if (getMyPlayer().getLocation().getY() > 6000) {
    1520. 

  1520. 		if (isInArea(3059, 9774, 3056, 9779)) {
    1521. 

  1521. 		    useStairs();
    1522. 

  1522. 		} else {
    1523. 

  1523. 		    walkPath(mineToStairs);
    1524. 

  1524. 		}
    1525. 

  1525. 	    }
    1526. 

  1526. 	}
    1527. 

  1527. 	return false;
    1528. 

  1528.     }
    1529. 

  1529. 

  1530.     public boolean walkToMine() {
    1531. 

  1531. 	if (alkharid) {
    1532. 

  1532. 	    walkPath(fixPath(generateProperPath(new RSTile(3300, 3311))));
    1533. 

  1533. 	} else if (draynor) {
    1534. 

  1534. 	    walkPath(bankToDraynor);
    1535. 

  1535. 	} else if (falador) {
    1536. 

  1536. 	    if (!(atMine() && atBank() && isInArea(3062, 3375, 3058, 3381)
    1537. 

  1537. 		    && isInArea(3064, 3371, 3058, 3374)
    1538. 

  1538. 		    && isInArea(3065, 3359, 3005, 3374) && getMyPlayer()
    1539. 

  1539. 		    .getLocation().getY() > 6000)) {
    1540. 

  1540. 		if (tileOnScreen(new RSTile(3061, 3373))) {
    1541. 

  1541. 		    walkTo(new RSTile(3061, 3373));
    1542. 

  1542. 		    while (!nearTile2(new RSTile(3061, 3373))) {
    1543. 

  1543. 			wait(random(10, 15));
    1544. 

  1544. 		    }
    1545. 

  1545. 		} else {
    1546. 

  1546. 		    walkPath(bankToDoor);
    1547. 

  1547. 		}
    1548. 

  1548. 	    }
    1549. 

  1549. 	    if (atMine()) {
    1550. 

  1550. 		return false;
    1551. 

  1551. 	    } else if (getMyPlayer().getLocation().getY() > 6000) {
    1552. 

  1552. 		walkPath(stairsToMine);
    1553. 

  1553. 	    } else if (isInArea(3062, 3375, 3058, 3381)) {
    1554. 

  1554. 		useStairs();
    1555. 

  1555. 	    } else if (isInArea(3064, 3371, 3058, 3374)) {
    1556. 

  1556. 		try {
    1557. 

  1557. 		    if (!isDoorOpen(new RSTile(3061, 3375), 11715)) {
    1558. 

  1558. 			openDoor(new RSTile(3061, 3374), new RSTile(3061, 3375));
    1559. 

  1559. 		    } else {
    1560. 

  1560. 			walkPath(bankToDoor);
    1561. 

  1561. 		    }
    1562. 

  1562. 		} catch (Exception e) {
    1563. 

  1563. 

  1564. 		}
    1565. 

  1565. 	    } else if (isInArea(3065, 3359, 3005, 3374)) {
    1566. 

  1566. 		walkPath(bankToDoor);
    1567. 

  1567. 	    } else if (atBank()) {
    1568. 

  1568. 		walkPath(bankToDoor);
    1569. 

  1569. 	    }
    1570. 

  1570. 	}
    1571. 

  1571. 	return false;
    1572. 

  1572.     }
    1573. 

  1573. 

  1574.     // ANTICOMBAT METHOD
    1575. 

  1575.     public void combat() {
    1576. 

  1576. 	RSTile runAwayTile = new RSTile(0, 0);
    1577. 

  1577. 	if (falador) {
    1578. 

  1578. 	    runAwayTile = new RSTile(3051, 9774);
    1579. 

  1579. 	} else if (alkharid) {
    1580. 

  1580. 	    runAwayTile = new RSTile(3299, 3298);
    1581. 

  1581. 	}
    1582. 

  1582. 	if (falador || alkharid) {
    1583. 

  1583. 	    if (getMyPlayer().isInCombat()) {
    1584. 

  1584. 		if (tileOnMap(runAwayTile)) {
    1585. 

  1585. 		    walkTile(runAwayTile);
    1586. 

  1586. 		} else {
    1587. 

  1587. 		    walkPath(randomizePath(
    1588. 

  1588. 			    fixPath(generateProperPath(runAwayTile)), 0, 0));
    1589. 

  1589. 		}
    1590. 

  1590. 		while (!nearTile(runAwayTile)) {
    1591. 

  1591. 		    wait(random(10, 15));
    1592. 

  1592. 		}
    1593. 

  1593. 		wait(random(10000, 15000));
    1594. 

  1594. 		worldHop();
    1595. 

  1595. 	    }
    1596. 

  1596. 	}
    1597. 

  1597.     }
    1598. 

  1598. 

  1599.     // DOOR AND STAIRS METHODS
    1600. 

  1600.     public boolean isDoorOpen(RSTile location, int openDoor) {
    1601. 

  1601. 	RSObject o = getObjectAt(location);
    1602. 

  1602. 	int door = o.getID();
    1603. 

  1603. 	if (o != null && door == openDoor) {
    1604. 

  1604. 	    return true;
    1605. 

  1605. 	} else {
    1606. 

  1606. 	    return false;
    1607. 

  1607. 	}
    1608. 

  1608.     }
    1609. 

  1609. 

  1610.     public boolean useStairs() {
    1611. 

  1611. 	stairsUpTime = System.currentTimeMillis();
    1612. 

  1612. 	stairsDownTime = System.currentTimeMillis();
    1613. 

  1613. 	final RSObject object;
    1614. 

  1614. 	if (getMyPlayer().getLocation().getY() > 6000) {
    1615. 

  1615. 	    object = getNearestObjectByID(16, 30943);
    1616. 

  1616. 	} else {
    1617. 

  1617. 	    object = getNearestObjectByID(16, 30944);
    1618. 

  1618. 	}
    1619. 

  1619. 	if (object == null) {
    1620. 

  1620. 	    return false;
    1621. 

  1621. 	}
    1622. 

  1622. 	if (!Calculations.onScreen(Calculations.tileToScreen(object
    1623. 

  1623. 		.getLocation()))) {
    1624. 

  1624. 	    walkTile(object.getLocation());
    1625. 

  1625. 	    wait(random(50, 600));
    1626. 

  1626. 	    if (random(0, 4) < 3) {
    1627. 

  1627. 		moveMouse(random(100, 415), random(100, 237));
    1628. 

  1628. 	    }
    1629. 

  1629. 	    while (!nearTile(object.getLocation())) {
    1630. 

  1630. 		wait(random(10, 15));
    1631. 

  1631. 	    }
    1632. 

  1632. 	}
    1633. 

  1633. 	if (getMyPlayer().getLocation().getY() > 6000) {
    1634. 

  1634. 	    if (atObject(object, "Climb-up")) {
    1635. 

  1635. 		while (getMyPlayer().getLocation().getY() > 6000
    1636. 

  1636. 			&& System.currentTimeMillis() - stairsUpTime < 6000) {
    1637. 

  1637. 		    if (getMyPlayer().getLocation().getY() < 6000) {
    1638. 

  1638. 			return true;
    1639. 

  1639. 		    }
    1640. 

  1640. 		    if (System.currentTimeMillis() - stairsUpTime >= 6000) {
    1641. 

  1641. 			return false;
    1642. 

  1642. 		    }
    1643. 

  1643. 		}
    1644. 

  1644. 	    } else {
    1645. 

  1645. 		setCameraRotation(random(1, 359));
    1646. 

  1646. 	    }
    1647. 

  1647. 	} else {
    1648. 

  1648. 	    if (atObject(object, "Climb-down")) {
    1649. 

  1649. 		while (getMyPlayer().getLocation().getY() > 6000
    1650. 

  1650. 			&& System.currentTimeMillis() - stairsDownTime < 6000) {
    1651. 

  1651. 		    if (getMyPlayer().getLocation().getY() < 6000) {
    1652. 

  1652. 			return true;
    1653. 

  1653. 		    }
    1654. 

  1654. 		    if (System.currentTimeMillis() - stairsDownTime >= 6000) {
    1655. 

  1655. 			return false;
    1656. 

  1656. 		    }
    1657. 

  1657. 		}
    1658. 

  1658. 	    } else {
    1659. 

  1659. 		setCameraRotation(random(1, 359));
    1660. 

  1660. 	    }
    1661. 

  1661. 	}
    1662. 

  1662. 	while (getMyPlayer().isMoving()) {
    1663. 

  1663. 	    wait(random(200, 600));
    1664. 

  1664. 	}
    1665. 

  1665. 	return false;
    1666. 

  1666.     }
    1667. 

  1667. 

  1668.     public boolean jumpStile(RSTile a, RSTile b) {
    1669. 

  1669. 	long st = System.currentTimeMillis();
    1670. 

  1670. 	do {
    1671. 

  1671. 	    if ((System.currentTimeMillis() - st) > 750) {
    1672. 

  1672. 		setCameraRotation(random(0, 360));
    1673. 

  1673. 		st = System.currentTimeMillis();
    1674. 

  1674. 	    }
    1675. 

  1675. 	    moveMouse(midPoint(Calculations.tileToScreen(a), Calculations
    1676. 

  1676. 		    .tileToScreen(b)), 3, 3);
    1677. 

  1677. 	} while (!listContainsString(getMenuItems(), "limb-over"));
    1678. 

  1678. 	clickMouse(true);
    1679. 

  1679. 	wait(random(100, 200));
    1680. 

  1680. 	return true;
    1681. 

  1681.     }
    1682. 

  1682. 

  1683.     public boolean openDoor(RSTile a, RSTile b) {
    1684. 

  1684. 	long st = System.currentTimeMillis();
    1685. 

  1685. 	do {
    1686. 

  1686. 	    if ((System.currentTimeMillis() - st) > 750) {
    1687. 

  1687. 		setCameraRotation(random(0, 360));
    1688. 

  1688. 		st = System.currentTimeMillis();
    1689. 

  1689. 	    }
    1690. 

  1690. 	    moveMouse(midPoint(Calculations.tileToScreen(a), Calculations
    1691. 

  1691. 		    .tileToScreen(b)), 3, 3);
    1692. 

  1692. 	} while (!listContainsString(getMenuItems(), "pen"));
    1693. 

  1693. 	clickMouse(true);
    1694. 

  1694. 	wait(random(100, 200));
    1695. 

  1695. 	return true;
    1696. 

  1696.     }
    1697. 

  1697. 

  1698.     private boolean listContainsString(final java.util.List<String> list,
    1699. 

  1699. 	    final String string) {
    1700. 

  1700. 	try {
    1701. 

  1701. 	    int a;
    1702. 

  1702. 	    for (a = list.size() - 1; a-- >= 0;) {
    1703. 

  1703. 		if (list.get(a).contains(string)) {
    1704. 

  1704. 		    return true;
    1705. 

  1705. 		}
    1706. 

  1706. 	    }
    1707. 

  1707. 	} catch (final Exception e) {
    1708. 

  1708. 	}
    1709. 

  1709. 	return false;
    1710. 

  1710.     }
    1711. 

  1711. 

  1712.     public Point midPoint(Point p1, Point p2) {
    1713. 

  1713. 	return (new Point((p1.x + p2.x) / 2, (p1.y + p2.y) / 2));
    1714. 

  1714.     }
    1715. 

  1715. 

  1716.     // BANKING METHODS
    1717. 

  1717.     public void handleBank() {
    1718. 

  1718. 	int tries = 0;
    1719. 

  1719. 	if (!bank.isOpen()) {
    1720. 

  1720. 	    RSObject bankObject = getNearestObjectByID(bankBoothID);
    1721. 

  1721. 	    if (bank != null) {
    1722. 

  1722. 		if (!atTile(bankObject.getLocation(), "quickly")) {
    1723. 

  1723. 		    atObject(bankObject, "quickly");
    1724. 

  1724. 		}
    1725. 

  1725. 	    }
    1726. 

  1726. 	    while (!bank.isOpen() && tries < 10) {
    1727. 

  1727. 		wait(random(200, 500));
    1728. 

  1728. 		tries++;
    1729. 

  1729. 	    }
    1730. 

  1730. 	    if (!bank.isOpen()) {
    1731. 

  1731. 		bank.open();
    1732. 

  1732. 	    }
    1733. 

  1733. 	}
    1734. 

  1734. 	if (getInventoryCount(dontBank) > 0) {
    1735. 

  1735. 	    bank.depositAllExcept(dontBank);
    1736. 

  1736. 	} else {
    1737. 

  1737. 	    bank.depositAll();
    1738. 

  1738. 	}
    1739. 

  1739. 	if (random(-10, 10) > 0) {
    1740. 

  1740. 	    bank.close();
    1741. 

  1741. 	}
    1742. 

  1742.     }
    1743. 

  1743. 

  1744.     // MINING METHODs
    1745. 

  1745.     public boolean nextRock() {
    1746. 

  1746. 	final RSObject obj = getObjectAt(lastRock);
    1747. 

  1747. 	if (obj == null) {
    1748. 

  1748. 	    return true;
    1749. 

  1749. 	}
    1750. 

  1750. 	for (final int element : oreToMine2) {
    1751. 

  1751. 	    if (obj.getID() == element) {
    1752. 

  1752. 		return false;
    1753. 

  1753. 	    }
    1754. 

  1754. 	}
    1755. 

  1755. 	for (final int element : ironRock) {
    1756. 

  1756. 	    if (obj.getID() == element) {
    1757. 

  1757. 		return false;
    1758. 

  1758. 	    }
    1759. 

  1759. 	}
    1760. 

  1760. 	for (final int element : coalRock) {
    1761. 

  1761. 	    if (obj.getID() == element) {
    1762. 

  1762. 		return false;
    1763. 

  1763. 	    }
    1764. 

  1764. 	}
    1765. 

  1765. 	return true;
    1766. 

  1766.     }
    1767. 

  1767. 

  1768.     public RSObject oreToMine() {
    1769. 

  1769. 	RSObject r;
    1770. 

  1770. 	if (both) {
    1771. 

  1771. 	    r = getNearestObjectByID(addyRock);
    1772. 

  1772. 	    if (r != null) {
    1773. 

  1773. 		return r;
    1774. 

  1774. 	    } else {
    1775. 

  1775. 		r = getNearestObjectByID(mithRock);
    1776. 

  1776. 		if (r != null) {
    1777. 

  1777. 		    return r;
    1778. 

  1778. 		}
    1779. 

  1779. 	    }
    1780. 

  1780. 	} else if (addy) {
    1781. 

  1781. 	    r = getNearestObjectByID(addyRock);
    1782. 

  1782. 	    if (r != null) {
    1783. 

  1783. 		return r;
    1784. 

  1784. 	    }
    1785. 

  1785. 	} else {
    1786. 

  1786. 	    r = getNearestObjectByID(mithRock);
    1787. 

  1787. 	    if (r != null) {
    1788. 

  1788. 		return r;
    1789. 

  1789. 	    }
    1790. 

  1790. 	}
    1791. 

  1791. 	return null;
    1792. 

  1792.     }
    1793. 

  1793. 

  1794.     public void clickRock(RSObject o) {
    1795. 

  1795. 	if (!atMine() || isInventoryFull()) {
    1796. 

  1796. 	    return;
    1797. 

  1797. 	}
    1798. 

  1798. 	if (distanceTo(o.getLocation()) >= 10) {
    1799. 

  1799. 	    walkTile(new RSTile(o.getLocation().getX() + random(-1, 1), o
    1800. 

  1800. 		    .getLocation().getY()
    1801. 

  1801. 		    + random(-1, 1)));
    1802. 

  1802. 	    while (!nearTile(new RSTile(o.getLocation().getX() + random(-1, 1),
    1803. 

  1803. 		    o.getLocation().getY() + random(-1, 1)))) {
    1804. 

  1804. 		wait(random(15, 30));
    1805. 

  1805. 	    }
    1806. 

  1806. 	}
    1807. 

  1807. 	if (!tileOnScreen(o.getLocation())) {
    1808. 

  1808. 	    turnToObject(o);
    1809. 

  1809. 	}
    1810. 

  1810. 	lastRock = o.getLocation();
    1811. 

  1811. 	try {
    1812. 

  1812. 	    if (Bot.getClient().isSpellSelected()) {
    1813. 

  1813. 		int randomTab = 0;
    1814. 

  1814. 		do {
    1815. 

  1815. 		    randomTab = random(1, 6);
    1816. 

  1816. 		} while (randomTab == getCurrentTab());
    1817. 

  1817. 		do {
    1818. 

  1818. 		    openTab(randomTab);
    1819. 

  1819. 		} while (Bot.getClient().isSpellSelected());
    1820. 

  1820. 	    }
    1821. 

  1821. 	    if (!atTile(o.getLocation(), "Mine")) {
    1822. 

  1822. 		atObject(o, "Mine");
    1823. 

  1823. 	    }
    1824. 

  1824. 	    int tries = 0;
    1825. 

  1825. 	    while (getMyPlayer().getAnimation() != 624 && tries < 10) {
    1826. 

  1826. 		wait(random(100, 300));
    1827. 

  1827. 		tries++;
    1828. 

  1828. 	    }
    1829. 

  1829. 	} catch (Exception e) {
    1830. 

  1830. 	}
    1831. 

  1831.     }
    1832. 

  1832. 

  1833.     public void rockMining() {
    1834. 

  1834. 	if (getObjectAt(lastRock) == null) {
    1835. 

  1835. 	    lastRock = new RSTile(0000, 0000);
    1836. 

  1836. 	}
    1837. 

  1837. 	if (nextRock() || getMyPlayer().getAnimation() == -1
    1838. 

  1838. 		&& !getMyPlayer().isMoving()) {
    1839. 

  1839. 	    rock = null;
    1840. 

  1840. 	    rock = oreToMine();
    1841. 

  1841. 

  1842. 	    if (rock == null) {
    1843. 

  1843. 		if (worldHop) {
    1844. 

  1844. 		    rock = getNearestObjectByID(oreToMine2);
    1845. 

  1845. 		    if (falador) {
    1846. 

  1846. 			if (rock == null
    1847. 

  1847. 				|| distanceTo(rock.getLocation()) >= 20) {
    1848. 

  1848. 			    status = "World Hopping";
    1849. 

  1849. 			    wait(random(1000, 2000));
    1850. 

  1850. 			    worldHop();
    1851. 

  1851. 			}
    1852. 

  1852. 		    } else if (draynor || alkharid) {
    1853. 

  1853. 			if (rock == null) {
    1854. 

  1854. 			    status = "World Hopping";
    1855. 

  1855. 			    wait(random(1000, 2000));
    1856. 

  1856. 			    worldHop();
    1857. 

  1857. 			}
    1858. 

  1858. 		    }
    1859. 

  1859. 		} else {
    1860. 

  1860. 		    if (alkharid) {
    1861. 

  1861. 			RSObject iron = getNearestObjectByID(ironRock);
    1862. 

  1862. 			if (iron == null) {
    1863. 

  1863. 			    antiBan();
    1864. 

  1864. 			    wait(random(400, 800));
    1865. 

  1865. 			} else {
    1866. 

  1866. 			    clickRock(iron);
    1867. 

  1867. 			}
    1868. 

  1868. 		    } else if (draynor) {
    1869. 

  1869. 			RSObject rock = getNearestObjectByID(coalRock);
    1870. 

  1870. 			if (rock == null) {
    1871. 

  1871. 			    antiBan();
    1872. 

  1872. 			    wait(random(400, 800));
    1873. 

  1873. 			} else {
    1874. 

  1874. 			    clickRock(rock);
    1875. 

  1875. 			}
    1876. 

  1876. 		    } else if (falador) {
    1877. 

  1877. 			RSObject rock = getNearestObjectByID(ironRock);
    1878. 

  1878. 			if (rock == null) {
    1879. 

  1879. 			    antiBan();
    1880. 

  1880. 			    wait(random(400, 800));
    1881. 

  1881. 			} else {
    1882. 

  1882. 			    clickRock(rock);
    1883. 

  1883. 			}
    1884. 

  1884. 		    }
    1885. 

  1885. 		}
    1886. 

  1886. 	    } else {
    1887. 

  1887. 		clickRock(rock);
    1888. 

  1888. 	    }
    1889. 

  1889. 	}
    1890. 

  1890.     }
    1891. 

  1891. 

  1892.     // CAMERA AND MOUSE MOVEMENT METHODS
    1893. 

  1893.     public void turnCamera() {
    1894. 

  1894. 	final char[] LR = new char[] { KeyEvent.VK_LEFT, KeyEvent.VK_RIGHT };
    1895. 

  1895. 	final char[] UD = new char[] { KeyEvent.VK_DOWN, KeyEvent.VK_UP };
    1896. 

  1896. 	final char[] LRUD = new char[] { KeyEvent.VK_LEFT, KeyEvent.VK_RIGHT,
    1897. 

  1897. 		KeyEvent.VK_UP, KeyEvent.VK_DOWN };
    1898. 

  1898. 	final int random2 = random(0, 2);
    1899. 

  1899. 	final int random1 = random(0, 2);
    1900. 

  1900. 	final int random4 = random(0, 4);
    1901. 

  1901. 

  1902. 	if (random(0, 3) == 0) {
    1903. 

  1903. 	    Bot.getInputManager().pressKey(LR[random1]);
    1904. 

  1904. 	    wait(random(100, 400));
    1905. 

  1905. 	    Bot.getInputManager().pressKey(UD[random2]);
    1906. 

  1906. 	    wait(random(100, 200));
    1907. 

  1907. 	    Bot.getInputManager().releaseKey(UD[random2]);
    1908. 

  1908. 	    wait(random(100, 400));
    1909. 

  1909. 	    Bot.getInputManager().releaseKey(LR[random1]);
    1910. 

  1910. 	} else {
    1911. 

  1911. 	    Bot.getInputManager().pressKey(LRUD[random4]);
    1912. 

  1912. 	    wait(random(500, 900));
    1913. 

  1913. 	    Bot.getInputManager().releaseKey(LRUD[random4]);
    1914. 

  1914. 	}
    1915. 

  1915.     }
    1916. 

  1916. 

  1917.     public void moveMouse() {
    1918. 

  1918. 	moveMouse(random(0, 750), random(0, 750), 50, 50);
    1919. 

  1919. 	wait(random(200, 600));
    1920. 

  1920.     }
    1921. 

  1921. 

  1922.     // ON FINISH
    1923. 

  1923.     public void onFinish() {
    1924. 

  1924. 	Bot.getEventManager().removeListener(PaintListener.class, this);
    1925. 

  1925. 	antiban.stopThread = true;
    1926. 

  1926. 	price.stop = true;
    1927. 

  1927. 	if (random(-10, 10) > 0) {
    1928. 

  1928. 	    final int x = 0;
    1929. 

  1929. 	    final int y = random(0, 500);
    1930. 

  1930. 	    moveMouse(x, y);
    1931. 

  1931. 	} else {
    1932. 

  1932. 	    final int x = ran…
    1933.

Large files files are truncated, but you can click here to view the full file